@zenfs/core 2.4.1 → 2.4.3

package/COPYING.md

@@ -0,0 +1,24 @@
+_This document is supplemental to the license._
+
+Feel free to reach out if you have any concerns regarding licensing. You can create a new discussion [here](https://github.com/orgs/zen-fs/discussions/new?category=q-a).
+
+Regarding section 4(b) of version 3 of the LGPL, you are permitted to link to a copy of the LGPL and this document rather than including the full text of both.
+
+#### Exception for web applications
+
+You are permitted to convey the Combined Work without meeting the requirements of section 4(d) of version 3 of the LGPL if
+
+- a) the Combined Work is only accessed by users from other computers over a network (i.e. a web application or website), and
+- b) you also provide the [Corresponding Source](https://www.gnu.org/licenses/gpl-3.0.html#:~:text=“Corresponding%20Source”) of The Library or an offer thereof.
+
+This exception does not excuse or waive any other requirement of the LGPL.
+
+The practical goal of this exception is to allow ZenFS to be used in modern web apps. For the avoidance of doubt, you are permitted to bundle and minify ZenFS in a web application. Linking to ZenFS' GitHub or npm page is sufficient to satisfy the above section (b) provided you do not modify ZenFS.
+
+For example, in a list of libraries you could have:
+
+> - [ZenFS](https://github.com/zen-fs/core), Licensed under the [LGPL 3.0 or later](https://www.gnu.org/licenses/lgpl-3.0.html) and [COPYING.md](https://github.com/zen-fs/core/blob/main/COPYING.md), Copyright © James Prevett and other ZenFS contributors
+
+**This is a very easy requirement, please respect it.**
+
+Before v2.4.0, ZenFS was licensed under the MIT. This still means you need to include the copyright notice and license.

package/{readme.md → README.md}

@@ -19,7 +19,12 @@ ZenFS supports a number of other backends.
 Many are provided as separate packages under `@zenfs`.
 More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
 
-You can find all of the packages available over on [NPM](https://www.npmjs.com/org/zenfs).
+You can find all of the packages available over on [NPM](https://www.npmjs.com/org/zenfs). Below is a list of the backends included with some of them:
+
+- @zenfs/archives: `Zip`, `Iso`
+- @zenfs/cloud: `Dropbox`, `GoogleDrive`, `S3Bucket`
+- @zenfs/dom: `WebAccess` (Web [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API)/OPFS), `IndexedDB`, `WebStorage` (`localStorage`/`sessionStorage`), `XML` (DOM elements)
+- @zenfs/emscripten: `Emscripten` and a plugin for Emscripten's file system API
 
 As an added bonus, all ZenFS backends support synchronous operations.
 Additionally, all of the backends included with the core are cross-platform.
@@ -34,7 +39,7 @@ npm install @zenfs/core
 
 If you're using ZenFS, especially for big projects, please consider supporting the project.
 Thousands of hours have been dedicated to its development.
-Your acknowledgment or financial support would go a long way toward improving ZenFS and its community.
+Your financial support would go a long way toward improving ZenFS and its community.
 
 ## Usage
 
@@ -69,8 +74,8 @@ await configure({
 		'/mnt/zip': { backend: Zip, data: await res.arrayBuffer() },
 		'/tmp': InMemory,
 		'/home': IndexedDB,
-	}
-};
+	},
+});
 ```
 
 Note that while you aren't required to use absolute paths for the keys of `mounts`, it is a good practice to do so.
@@ -140,7 +145,7 @@ await configure({
 	},
 });
 
-fs.mkdirSync('/mnt');
+fs.mkdirSync('/mnt/zip', { recursive: true });
 
 const res = await fetch('mydata.zip');
 const zipfs = await resolveMountConfig({ backend: Zip, data: await res.arrayBuffer() });
@@ -156,82 +161,19 @@ fs.umount('/mnt/zip'); // finished using the zip
 
 ### Devices and device files
 
-ZenFS includes support for device files. These are designed to follow Linux's device file behavior, for consistency and ease of use. You can automatically add some normal devices with the `addDevices` configuration option:
-
-```ts
-await configure({
-	mounts: {
-		/* ... */
-	},
-	addDevices: true,
-});
-
-fs.writeFileSync('/dev/null', 'Some data to be discarded');
-
-const randomData = new Uint8Array(100);
-
-const random = fs.openSync('/dev/random', 'r');
-fs.readSync(random, randomData);
-fs.closeSync(random);
-```
-
-You can create your own devices by implementing a `DeviceDriver`. For example, the null device looks similar to this:
-
-```ts
-const customNullDevice = {
-	name: 'custom_null',
-	// only 1 can exist per DeviceFS
-	singleton: true,
-	// optional if false
-	isBuffered: false,
-	read() {
-		return 0;
-	},
-	write() {
-		return 0;
-	},
-};
-```
-
-Note the actual implementation's write is slightly more complicated since it adds to the file position. You can find more information on the docs.
-
-Finally, if you'd like to use your custom device with the file system:
+ZenFS includes support for device files. These are designed to follow Linux's device file behavior, for consistency and ease of use. Check out the [Devices and Device Drivers](https://zenfs.dev/core/documents/Devices_and_Device_Drivers) documentation for more information.
 
-```ts
-import { addDevice, fs } from '@zenfs/core';
-
-addDevice(customNullDevice);
-
-fs.writeFileSync('/dev/custom', 'This gets discarded.');
-```
+## Bundling
 
-## Using with bundlers
+ZenFS exports a drop-in for Node's `fs` module, so you can use it for your bundler of preference using the default export.
 
-ZenFS exports a drop-in for Node's `fs` module (up to the version of `@types/node` in package.json), so you can use it for your bundler of preference using the default export.
+> [!IMPORTANT]
+> See [COPYING.md](./COPYING.md)
 
 ## Sponsors
 
-A huge thank you to [![Deco.cx logo](https://avatars.githubusercontent.com/deco-cx?size=20) Deco.cx](https://github.com/deco-cx) for sponsoring ZenFS and helping to make this possible.
-
-## Building
-
-- Make sure you have Node and NPM installed. You must have Node v22 or newer.
-- Install dependencies with `npm install`
-- Build using `npx tsc` or `npm run build`
-- You can find the built code in `dist`.
+A huge thank you to [deco.cx](https://github.com/deco-cx) for sponsoring ZenFS and helping to make this possible.
 
 ## Contact and Support
 
 You can reach out [on Discord](https://zenfs.dev/discord) or by emailing jp@zenfs.dev
-
-### Testing
-
-Run unit tests with:
-
-- `npm test` to run all tests using the default configuration
-- `npx zenfs-test -abc` to run the common tests and run the full FS suite against all included backends
-    - You can also run this command to test your own backends, the `--auto` (`-a`) flag will automatically detect any setup scripts matching `tests/setup/*` or `tests/setup-*.ts`. If you do, you'll need to include the `c8` dependency for coverage.
-
-### BrowserFS Fork
-
-ZenFS is a fork of [BrowserFS](https://github.com/jvilk/BrowserFS). If you are using ZenFS in a research paper, you may want to [cite BrowserFS](https://github.com/jvilk/BrowserFS#citing).

package/dist/backends/backend.d.ts

@@ -9,7 +9,7 @@ type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undef
  * @category Backends and Configuration
  */
 export type OptionsConfig<T> = {
-    [K in keyof T]: {
+    [K in Exclude<keyof T, keyof SharedConfig>]: {
         /**
          * The type of the option. Can be a:
          * - string given by `typeof`

package/dist/backends/fetch.js

@@ -6,7 +6,7 @@ import * as requests from 'utilium/requests.js';
 import { Index } from '../internal/file_index.js';
 import { IndexFS } from '../internal/index_fs.js';
 import { normalizePath } from '../utils.js';
-import { S_IFREG } from '../vfs/constants.js';
+import { S_IFREG } from '../constants.js';
 /** Parse and throw */
 function parseError(error) {
     if (!('tag' in error))

package/dist/backends/memory.js

@@ -1,4 +1,4 @@
-import { size_max } from '../vfs/constants.js';
+import { size_max } from '../constants.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction } from './store/map.js';
 /**

package/dist/backends/passthrough.d.ts

@@ -1,8 +1,7 @@
-import type * as fs from 'node:fs';
 import type { CreationOptions, UsageInfo } from '../internal/filesystem.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { type InodeLike } from '../internal/inode.js';
-export type NodeFS = typeof fs;
+import type { NodeFS } from '../node/types.js';
 /**
  * Passthrough backend options
  * @category Backends and Configuration

package/dist/backends/single_buffer.d.ts

@@ -26,6 +26,7 @@ declare const MetadataBlock_base: import("memium/decorators").StructFromTypedArr
  */
 export declare class MetadataBlock extends MetadataBlock_base<ArrayBufferLike> {
     readonly ['constructor']: typeof MetadataBlock;
+    private static readonly lockIndex;
     /**
      * The crc32c checksum for the metadata block.
      * @privateRemarks Keep this first!
@@ -37,7 +38,6 @@ export declare class MetadataBlock extends MetadataBlock_base<ArrayBufferLike> {
     accessor previous_offset: number;
     protected _previous?: MetadataBlock;
     get previous(): MetadataBlock | undefined;
-    protected get offsetHex(): string;
     /** Metadata entries. */
     accessor items: ArrayOf<MetadataEntry>;
     toString(long?: boolean): string;

package/dist/backends/single_buffer.js

@@ -86,8 +86,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
-import { alert, crit, err, warn } from 'kerium/log';
-import { array, offsetof, packed, sizeof } from 'memium';
+import { alert, crit, debug, err, warn } from 'kerium/log';
+import { array, offsetof, sizeof } from 'memium';
 import { $from, field, struct, types as t } from 'memium/decorators';
 import { BufferView } from 'utilium/buffer.js';
 import { crc32c } from 'utilium/checksum.js';
@@ -95,6 +95,7 @@ import { decodeUUID, encodeUUID } from 'utilium/string.js';
 import { _inode_version, Inode } from '../internal/inode.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction } from './store/map.js';
+const hex = (value) => '0x' + value.toString(16).padStart(8, '0');
 // eslint-disable-next-line @typescript-eslint/unbound-method
 const { format } = new Intl.NumberFormat('en-US', {
     notation: 'compact',
@@ -155,7 +156,7 @@ let MetadataEntry = (() => {
         get size() { return this.#size_accessor_storage; }
         set size(value) { this.#size_accessor_storage = value; }
         toString() {
-            return `<MetadataEntry @ 0x${this.byteOffset.toString(16).padStart(8, '0')}>`;
+            return `<MetadataEntry @ ${hex(this.byteOffset)}>`;
         }
         constructor() {
             super(...arguments);
@@ -216,8 +217,8 @@ let MetadataBlock = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             MetadataBlock = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static lockIndex = offsetof(MetadataBlock, 'locked') / Int32Array.BYTES_PER_ELEMENT;
         #checksum_accessor_storage = __runInitializers(this, _checksum_initializers, void 0);
         /**
          * The crc32c checksum for the metadata block.
@@ -240,27 +241,24 @@ let MetadataBlock = (() => {
             this._previous ??= new MetadataBlock(this.buffer, this.previous_offset);
             return this._previous;
         }
-        get offsetHex() {
-            return '0x' + this.byteOffset.toString(16).padStart(8, '0');
-        }
         #items_accessor_storage = __runInitializers(this, _items_initializers, void 0);
         /** Metadata entries. */
         get items() { return this.#items_accessor_storage; }
         set items(value) { this.#items_accessor_storage = value; }
         toString(long = false) {
             if (!long)
-                return `<MetadataBlock @ ${this.offsetHex}>`;
+                return `<MetadataBlock @ ${hex(this.byteOffset)}>`;
             let text = [
-                `---- Metadata block at ${this.offsetHex} ----`,
-                `Checksum: 0x${this.checksum.toString(16).padStart(8, '0')}`,
+                `---- Metadata block at ${hex(this.byteOffset)} ----`,
+                `Checksum: ${hex(this.checksum)}`,
                 `Last updated: ${new Date(Number(this.timestamp)).toLocaleString()}`,
-                `Previous block: 0x${this.previous_offset.toString(16).padStart(8, '0')}`,
+                `Previous block: ${hex(this.previous_offset)}`,
                 'Entries:',
             ].join('\n');
             for (const entry of this.items) {
                 if (!entry.offset)
                     continue;
-                text += `\n\t0x${entry.id.toString(16).padStart(8, '0')}: ${format(entry.size).padStart(5)} at 0x${entry.offset.toString(16).padStart(8, '0')}`;
+                text += `\n\t${hex(entry.id)}: ${format(entry.size).padStart(5)} at ${hex(entry.offset)}`;
             }
             return text;
         }
@@ -276,28 +274,26 @@ let MetadataBlock = (() => {
          */
         waitUnlocked(depth = 0) {
             if (depth > max_lock_attempts)
-                throw crit(withErrno('EBUSY', `sbfs: exceeded max attempts waiting for metadata block at ${this.offsetHex} to be unlocked`));
-            const i = this.length - 1;
-            if (!Atomics.load(this, i))
+                throw crit(withErrno('EBUSY', `sbfs: exceeded max attempts waiting for metadata block at ${hex(this.byteOffset)} to be unlocked`));
+            if (!Atomics.load(this, MetadataBlock.lockIndex))
                 return;
-            switch (Atomics.wait(this, i, 1)) {
+            switch (Atomics.wait(this, MetadataBlock.lockIndex, 1)) {
                 case 'ok':
                     break;
                 case 'not-equal':
                     depth++;
-                    err(`sbfs: waiting for metadata block at ${this.offsetHex} to be unlocked (${depth}/${max_lock_attempts})`);
+                    err(`sbfs: waiting for metadata block at ${hex(this.byteOffset)} to be unlocked (${depth}/${max_lock_attempts})`);
                     return this.waitUnlocked(depth);
                 case 'timed-out':
-                    throw crit(withErrno('EBUSY', `sbfs: timed out waiting for metadata block at ${this.offsetHex} to be unlocked`));
+                    throw crit(withErrno('EBUSY', `sbfs: timed out waiting for metadata block at ${hex(this.byteOffset)} to be unlocked`));
             }
         }
         lock() {
             this.waitUnlocked();
-            const i = offsetof(this, 'locked');
-            Atomics.store(this, i, 1);
+            Atomics.store(this, MetadataBlock.lockIndex, 1);
             const release = () => {
-                Atomics.store(this, i, 0);
-                Atomics.notify(this, i, 1);
+                Atomics.store(this, MetadataBlock.lockIndex, 0);
+                Atomics.notify(this, MetadataBlock.lockIndex, 1);
             };
             release[Symbol.dispose] = release;
             return release;
@@ -306,6 +302,9 @@ let MetadataBlock = (() => {
             super(...arguments);
             __runInitializers(this, _locked_extraInitializers);
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return MetadataBlock = _classThis;
 })();
@@ -425,7 +424,7 @@ let SuperBlock = (() => {
                 throw crit(withErrno('EIO', 'sbfs: checksum mismatch for super block'));
             this.metadata = new MetadataBlock(this.buffer, this.metadata_offset);
             if (this.metadata.checksum !== checksum(this.metadata))
-                throw crit(withErrno('EIO', `sbfs: checksum mismatch for metadata block (saved ${this.metadata.checksum.toString(16).padStart(8, '0')}, computed ${checksum(this.metadata).toString(16).padStart(8, '0')})`));
+                throw crit(withErrno('EIO', `sbfs: checksum mismatch for metadata block (saved ${hex(this.metadata.checksum)}, computed ${hex(checksum(this.metadata))})`));
             if (this.inode_format != _inode_version)
                 throw crit(withErrno('EIO', 'sbfs: inode format mismatch'));
             if (this.metadata_block_size != sizeof(MetadataBlock))
@@ -506,6 +505,7 @@ let SuperBlock = (() => {
             this.metadata_offset = metadata.byteOffset;
             _update(metadata);
             _update(this);
+            debug(`sbfs: rotated metadata block at ${hex(metadata.previous_offset)} with new block at ${hex(offset)}`);
             return metadata;
         }
         /**
@@ -541,7 +541,10 @@ export { SuperBlock };
  * Note we don't include the checksum when computing a new one.
  */
 function checksum(value) {
-    return crc32c(new Uint8Array(value.buffer, value.byteOffset + 4, sizeof(value) - 4));
+    let length = sizeof(value) - 4;
+    if (value instanceof MetadataBlock)
+        length -= Int32Array.BYTES_PER_ELEMENT;
+    return crc32c(new Uint8Array(value.buffer, value.byteOffset + 4, length));
 }
 /**
  * Update a block's checksum and timestamp.

package/dist/backends/store/fs.js

@@ -58,10 +58,10 @@ import { _throw, canary, encodeUTF8 } from 'utilium';
 import { extendBuffer } from 'utilium/buffer.js';
 import { Index } from '../../internal/file_index.js';
 import { FileSystem } from '../../internal/filesystem.js';
-import { Inode, isDirectory, rootIno } from '../../internal/inode.js';
+import { Inode, isDirectory, isFile, rootIno } from '../../internal/inode.js';
 import { basename, dirname, join, parse, relative } from '../../path.js';
 import { decodeDirListing, encodeDirListing } from '../../utils.js';
-import { S_IFDIR, S_IFREG, size_max } from '../../vfs/constants.js';
+import { S_IFDIR, S_IFREG, size_max } from '../../constants.js';
 import { WrappedTransaction } from './store.js';
 /**
  * A file system which uses a `Store`
@@ -304,7 +304,7 @@ export class StoreFS extends FileSystem {
                 : decodeDirListing((await tx.get(newDirNode.data)) ?? _throw(withErrno('ENODATA')));
             if (newDirList[_new.base]) {
                 const existing = new Inode((await tx.get(newDirList[_new.base])) ?? _throw(withErrno('ENOENT')));
-                if (!existing.toStats().isFile())
+                if (!isFile(existing))
                     throw withErrno('EISDIR');
                 await tx.remove(existing.data);
                 await tx.remove(newDirList[_new.base]);
@@ -353,7 +353,7 @@ export class StoreFS extends FileSystem {
             const newDirList = sameParent ? oldDirList : decodeDirListing(tx.getSync(newDirNode.data) ?? _throw(withErrno('ENODATA')));
             if (newDirList[_new.base]) {
                 const existing = new Inode(tx.getSync(newDirList[_new.base]) ?? _throw(withErrno('ENOENT')));
-                if (!existing.toStats().isFile())
+                if (!isFile(existing))
                     throw withErrno('EISDIR');
                 tx.removeSync(existing.data);
                 tx.removeSync(newDirList[_new.base]);

package/dist/config.js

@@ -4,9 +4,9 @@ import { defaultContext } from './internal/contexts.js';
 import { createCredentials } from './internal/credentials.js';
 import { DeviceFS } from './internal/devices.js';
 import { FileSystem } from './internal/filesystem.js';
+import { exists, mkdir, stat } from './node/promises.js';
 import { _setAccessChecks } from './vfs/config.js';
-import * as fs from './vfs/index.js';
-import { mounts } from './vfs/shared.js';
+import { mount, mounts, umount } from './vfs/shared.js';
 /**
  * Update the configuration of a file system.
  * @category Backends and Configuration
@@ -69,8 +69,8 @@ export async function configureSingle(configuration) {
         throw new TypeError('Invalid single mount point configuration');
     }
     const resolved = await resolveMountConfig(configuration);
-    fs.umount('/');
-    fs.mount('/', resolved);
+    umount('/');
+    mount('/', resolved);
 }
 /**
  * Like `fs.mount`, but it also creates missing directories.
@@ -78,19 +78,19 @@ export async function configureSingle(configuration) {
  * This is implemented as a separate function to avoid a circular dependency between vfs/shared.ts and other vfs layer files.
  * @internal
  */
-async function mount(path, mount) {
+async function mountWithMkdir(path, fs) {
     if (path == '/') {
-        fs.mount(path, mount);
+        mount(path, fs);
         return;
     }
-    const stats = await fs.promises.stat(path).catch(() => null);
+    const stats = await stat(path).catch(() => null);
     if (!stats) {
-        await fs.promises.mkdir(path, { recursive: true });
+        await mkdir(path, { recursive: true });
     }
     else if (!stats.isDirectory()) {
         throw withErrno('ENOTDIR', 'Missing directory at mount point: ' + path);
     }
-    fs.mount(path, mount);
+    mount(path, fs);
 }
 /**
  * @category Backends and Configuration
@@ -124,8 +124,8 @@ export async function configure(configuration) {
                 mountConfig.caseFold ??= configuration.caseFold;
             }
             if (point == '/')
-                fs.umount('/');
-            await mount(point, await resolveMountConfig(mountConfig));
+                umount('/');
+            await mountWithMkdir(point, await resolveMountConfig(mountConfig));
         }
     }
     for (const fs of mounts.values()) {
@@ -135,17 +135,17 @@ export async function configure(configuration) {
         const devfs = new DeviceFS();
         devfs.addDefaults();
         await devfs.ready();
-        await mount('/dev', devfs);
+        await mountWithMkdir('/dev', devfs);
     }
     if (configuration.defaultDirectories) {
         for (const dir of _defaultDirectories) {
-            if (await fs.promises.exists(dir)) {
-                const stats = await fs.promises.stat(dir);
+            if (await exists(dir)) {
+                const stats = await stat(dir);
                 if (!stats.isDirectory())
                     log.warn('Default directory exists but is not a directory: ' + dir);
             }
             else
-                await fs.promises.mkdir(dir);
+                await mkdir(dir);
         }
     }
 }

package/dist/context.js

@@ -3,7 +3,8 @@ 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';
+import * as fs from './node/index.js';
+import * as xattr from './vfs/xattr.js';
 // 0 is reserved for the global/default context
 let _nextId = 1;
 /**
@@ -33,7 +34,7 @@ export function bindContext({ root = this?.root || '/', pwd = this?.pwd || '/',
         fs: {
             ...bindFunctions(fs, ctx),
             promises: bindFunctions(fs.promises, ctx),
-            xattr: bindFunctions(fs.xattr, ctx),
+            xattr: bindFunctions(xattr, ctx),
         },
         path: bindFunctions(path, ctx),
         bind: (init) => {

package/dist/index.d.ts

@@ -1,12 +1,18 @@
+/*!
+ * @zenfs/core — https://npmjs.com/package/@zenfs/core
+ * Copyright © James Prevett and other ZenFS contributors.
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';
 export * from './internal/index.js';
 export * from './mixins/index.js';
-export * from './vfs/stats.js';
 export * from './utils.js';
 export { mounts } from './vfs/shared.js';
-export * from './vfs/index.js';
+import * as fs from './node/compat.js';
+/** @primaryExport */
 export { fs };
-import * as fs from './vfs/index.js';
 export default fs;
+export * from './node/compat.js';
+export * as vfs from './vfs/index.js';

package/dist/index.js

@@ -1,15 +1,20 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
+/*!
+ * @zenfs/core — https://npmjs.com/package/@zenfs/core
+ * Copyright © James Prevett and other ZenFS contributors.
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';
 export * from './internal/index.js';
 export * from './mixins/index.js';
-export * from './vfs/stats.js';
 export * from './utils.js';
 export { mounts } from './vfs/shared.js';
-export * from './vfs/index.js';
+import * as fs from './node/compat.js';
+/** @primaryExport */
 export { fs };
-import * as fs from './vfs/index.js';
 export default fs;
+export * from './node/compat.js';
+export * as vfs from './vfs/index.js';
 import $pkg from '../package.json' with { type: 'json' };
 globalThis.__zenfs__ = Object.assign(Object.create(fs), { _version: $pkg.version });

package/dist/internal/contexts.d.ts

@@ -1,7 +1,8 @@
 import type { Bound } from 'utilium';
+import type * as fs from '../node/index.js';
 import type * as path from '../path.js';
-import type { SyncHandle } from '../vfs/file.js';
-import type * as fs from '../vfs/index.js';
+import type { Handle } from '../vfs/file.js';
+import type * as xattr from '../vfs/xattr.js';
 import type { Credentials, CredentialsInit } from './credentials.js';
 /**
  * A context used for FS operations
@@ -21,7 +22,7 @@ export interface FSContext {
     /** 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>;
+    descriptors: Map<number, Handle>;
     /** The parent context, if any. */
     parent: V_Context;
     /** The child contexts */
@@ -38,7 +39,7 @@ export type V_Context = void | null | (Partial<FSContext> & object);
 export interface BoundContext extends FSContext {
     fs: Bound<typeof fs, FSContext> & {
         promises: Bound<typeof fs.promises, FSContext>;
-        xattr: Bound<typeof fs.xattr, FSContext>;
+        xattr: Bound<typeof xattr, FSContext>;
     };
     /** Path functions, bound to the context */
     path: Bound<typeof path, FSContext>;

package/dist/internal/devices.js

@@ -8,7 +8,7 @@ import { decodeUTF8, omit } from 'utilium';
 import { InMemoryStore } from '../backends/memory.js';
 import { StoreFS } from '../backends/store/fs.js';
 import { basename, dirname } from '../path.js';
-import { S_IFCHR } from '../vfs/constants.js';
+import { S_IFCHR } from '../constants.js';
 import { Inode } from './inode.js';
 /**
  * A temporary file system that manages and interfaces with devices

package/dist/internal/error.d.ts

@@ -1,4 +1,5 @@
-import { Exception, type ExceptionJSON } from 'kerium';
+import { Exception, type ExceptionExtra, type ExceptionJSON } from 'kerium';
+import type { FileSystem } from './filesystem.js';
 /**
  * @deprecated Use {@link ExceptionJSON} instead
  * @category Internals
@@ -15,4 +16,12 @@ export declare const ErrnoError: typeof Exception;
  */
 export type ErrnoError = Exception;
 export declare function withPath<E extends Exception>(e: E, path: string): E;
-export declare function wrap<const FS, const Prop extends keyof FS & string>(fs: FS, prop: Prop, path: string, dest?: string): FS[Prop];
+/**
+ * @internal @hidden
+ */
+export declare function wrap<const FS, const Prop extends keyof FS & string>(fs: FS, prop: Prop, path: string | ExceptionExtra, dest?: string): FS[Prop];
+/**
+ * @internal
+ * Wraps an `fs` so that thrown errors aren't empty
+ */
+export declare function withExceptionContext<const FS extends FileSystem>(fs: FS, context: ExceptionExtra): FS;