@zenfs/core 2.4.2 → 2.4.4

package/COPYING.md

@@ -1,18 +1,24 @@
 _This document is supplemental to the license._
 
-**This is a very easy requirement, please respect it.**
-Feel free to reach out if you have any concerns regarding licensing.
+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
 
-If you convey copies of ZenFS (including in bundles), you must meet section 4 and 5 of the license. This includes at a minimum:
+You are permitted to convey the Combined Work without meeting the requirements of section 4(d) of version 3 of the LGPL if
 
-- disclosure that ZenFS is in use
-- linking to the GitHub or npm pages
-- referencing the license and copyright.
+- 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), LGPL-3.0-or-later, Copyright © James Prevett and other ZenFS contributors
+> - [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
 
-<br />
+**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/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/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,7 +86,7 @@ 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 { 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';
@@ -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/context.d.ts

@@ -11,4 +11,4 @@ export declare const boundContexts: Map<number, BoundContext>;
  * Note that the default credentials of a bound context are copied from the global credentials.
  * @category Contexts
  */
-export declare function bindContext(this: void | null | FSContext, { root, pwd, credentials }?: ContextInit): BoundContext;
+export declare function bindContext(this: V_Context, init?: ContextInit): BoundContext;

package/dist/context.js

@@ -1,12 +1,10 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import { UV } from 'kerium';
 import { bindFunctions } from 'utilium';
-import { defaultContext } from './internal/contexts.js';
-import { createCredentials } from './internal/credentials.js';
-import * as path from './path.js';
+import { contextOf, createChildContext } from './internal/contexts.js';
 import * as fs from './node/index.js';
+import * as path from './path.js';
 import * as xattr from './vfs/xattr.js';
-// 0 is reserved for the global/default context
-let _nextId = 1;
 /**
  * A map of all contexts.
  * @internal
@@ -18,19 +16,12 @@ export const boundContexts = new Map();
  * Note that the default credentials of a bound context are copied from the global credentials.
  * @category Contexts
  */
-export function bindContext({ root = this?.root || '/', pwd = this?.pwd || '/', credentials = structuredClone(defaultContext.credentials) } = {}) {
-    const parent = this ?? defaultContext;
-    const ctx = {
-        id: _nextId++,
-        root,
-        pwd,
-        credentials: createCredentials(credentials),
-        descriptors: new Map(),
-        parent,
-        children: [],
-    };
-    const bound = {
-        ...ctx,
+export function bindContext(init = {}) {
+    const $ = contextOf(this);
+    if (!fs.statSync.call(this, $.root).isDirectory())
+        throw UV('ENOTDIR', { syscall: 'chroot', path: $.root });
+    const ctx = createChildContext($, init);
+    const bound = Object.assign(ctx, {
         fs: {
             ...bindFunctions(fs, ctx),
             promises: bindFunctions(fs.promises, ctx),
@@ -42,7 +33,7 @@ export function bindContext({ root = this?.root || '/', pwd = this?.pwd || '/',
             ctx.children.push(child);
             return child;
         },
-    };
+    });
     boundContexts.set(ctx.id, bound);
     return bound;
 }

package/dist/internal/contexts.d.ts

@@ -4,11 +4,18 @@ import type * as path from '../path.js';
 import type { Handle } from '../vfs/file.js';
 import type * as xattr from '../vfs/xattr.js';
 import type { Credentials, CredentialsInit } from './credentials.js';
+/**
+ * Symbol used for context branding
+ * @internal @hidden
+ */
+declare const kIsContext: unique symbol;
 /**
  * A context used for FS operations
  * @category Contexts
  */
 export interface FSContext {
+    /** The unique ID of the context */
+    readonly [kIsContext]: boolean;
     /** The unique ID of the context */
     readonly id: number;
     /**
@@ -22,16 +29,16 @@ 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, Handle>;
+    readonly descriptors: Map<number, Handle>;
     /** The parent context, if any. */
-    parent: V_Context;
+    readonly parent: FSContext | null;
     /** The child contexts */
-    children: FSContext[];
+    readonly children: FSContext[];
 }
 /**
  * maybe an FS context
  */
-export type V_Context = void | null | (Partial<FSContext> & object);
+export type V_Context = unknown;
 /**
  * Allows you to restrict operations to a specific root path and set of credentials.
  * @category Contexts
@@ -62,3 +69,16 @@ export interface ContextInit {
  * @category Contexts
  */
 export declare const defaultContext: FSContext;
+export declare function contextOf($: unknown): FSContext;
+/**
+ * Create a blank FS Context
+ * @internal
+ * @category Contexts
+ * @todo Make sure parent root can't be escaped
+ *
+ * This exists so that `kIsContext` is not exported and to make sure the context is "secure".
+ */
+export declare function createChildContext(parent: FSContext, init?: ContextInit): FSContext & {
+    parent: FSContext;
+};
+export {};

package/dist/internal/contexts.js

@@ -1,10 +1,16 @@
 import { createCredentials } from './credentials.js';
+/**
+ * Symbol used for context branding
+ * @internal @hidden
+ */
+const kIsContext = Symbol('ZenFSContext');
 /**
  * The default/global context.
  * @internal @hidden
  * @category Contexts
  */
 export const defaultContext = {
+    [kIsContext]: true,
     id: 0,
     root: '/',
     pwd: '/',
@@ -13,3 +19,37 @@ export const defaultContext = {
     parent: null,
     children: [],
 };
+export function contextOf($) {
+    return typeof $ === 'object' && $ !== null && kIsContext in $ ? $ : defaultContext;
+}
+// 0 is reserved for the global/default context
+let _nextId = 1;
+/**
+ * Create a blank FS Context
+ * @internal
+ * @category Contexts
+ * @todo Make sure parent root can't be escaped
+ *
+ * This exists so that `kIsContext` is not exported and to make sure the context is "secure".
+ */
+export function createChildContext(parent, init = {}) {
+    const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials) } = init;
+    const ctx = {
+        [kIsContext]: true,
+        id: _nextId++,
+        root,
+        pwd,
+        credentials: createCredentials(credentials),
+        descriptors: new Map(),
+        parent: parent,
+        children: [],
+    };
+    Object.defineProperties(ctx, {
+        id: { configurable: false, writable: false },
+        credentials: { configurable: false, writable: false },
+        descriptors: { configurable: false, writable: false },
+        parent: { configurable: false, writable: false },
+        children: { configurable: false, writable: false },
+    });
+    return ctx;
+}

package/dist/internal/inode.js

@@ -39,9 +39,9 @@ import { sizeof } from 'memium';
 import { $from, field, struct, types as t } from 'memium/decorators';
 import { decodeUTF8, encodeUTF8, pick } from 'utilium';
 import { BufferView } from 'utilium/buffer.js';
-import { Stats } from '../node/stats.js';
 import * as c from '../constants.js';
-import { defaultContext } from './contexts.js';
+import { Stats } from '../node/stats.js';
+import { contextOf } from './contexts.js';
 /**
  * Root inode
  * @hidden
@@ -620,7 +620,7 @@ export function isFIFO(metadata) {
  * @internal
  */
 export function hasAccess($, inode, access) {
-    const credentials = $?.credentials || defaultContext.credentials;
+    const { credentials } = contextOf($);
     if (isSymbolicLink(inode) || credentials.euid === 0 || credentials.egid === 0)
         return true;
     let perm = 0;

package/dist/node/sync.js

@@ -467,7 +467,7 @@ export function lutimesSync(path, atime, mtime) {
 lutimesSync;
 export function realpathSync(path, options) {
     const encoding = typeof options == 'string' ? options : (options?.encoding ?? 'utf8');
-    path = normalizePath(path);
+    path = normalizePath(path, true);
     const { fullPath } = _sync.resolve(this, path);
     if (encoding == 'utf8' || encoding == 'utf-8')
         return fullPath;

package/dist/path.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { defaultContext } from './internal/contexts.js';
+import { contextOf } from './internal/contexts.js';
 import { globToRegex } from './utils.js';
 export const sep = '/';
 function validateObject(str, name) {
@@ -81,7 +81,7 @@ export function formatExt(ext) {
 }
 export function resolve(...parts) {
     let resolved = '';
-    for (const part of [...parts.reverse(), this?.pwd ?? defaultContext.pwd]) {
+    for (const part of [...parts.reverse(), contextOf(this).pwd]) {
         if (!part?.length)
             continue;
         resolved = `${part}/${resolved}`;
@@ -334,7 +334,7 @@ export function format(pathObject) {
     return dir === pathObject.root ? `${dir}${base}` : `${dir}/${base}`;
 }
 export function parse(path) {
-    const isAbsolute = path.startsWith('/');
+    const isAbsolute = path[0] === '/';
     const ret = { root: isAbsolute ? '/' : '', dir: '', base: '', ext: '', name: '' };
     if (path.length === 0)
         return ret;

package/dist/utils.d.ts

@@ -2,6 +2,7 @@ import { type Exception } from 'kerium';
 import type * as fs from 'node:fs';
 import type { Worker as NodeWorker } from 'node:worker_threads';
 import { type OptionalTuple } from 'utilium';
+import type { V_Context } from './internal/contexts.js';
 declare global {
     function atob(data: string): string;
     function btoa(data: string): string;
@@ -31,8 +32,9 @@ export declare function normalizeTime(time: fs.TimeLike): number;
 /**
  * Normalizes a path
  * @internal
+ * @todo clean this up and make it so `path.resolve` is only called when an explicit context is passed (i.e. `normalizePath(..., $)` to use `path.resolve`)
  */
-export declare function normalizePath(p: fs.PathLike, noResolve?: boolean): string;
+export declare function normalizePath(this: V_Context, p: fs.PathLike, noResolve?: boolean): string;
 /**
  * Normalizes options
  * @param options options to normalize

package/dist/utils.js

@@ -51,6 +51,7 @@ export function normalizeTime(time) {
 /**
  * Normalizes a path
  * @internal
+ * @todo clean this up and make it so `path.resolve` is only called when an explicit context is passed (i.e. `normalizePath(..., $)` to use `path.resolve`)
  */
 export function normalizePath(p, noResolve = false) {
     if (p instanceof URL) {
@@ -67,7 +68,7 @@ export function normalizePath(p, noResolve = false) {
         throw withErrno('EINVAL', 'Path can not be empty');
     p = p.replaceAll(/[/\\]+/g, '/');
     // Note: PWD is not resolved here, it is resolved later.
-    return noResolve ? p : resolve(p);
+    return noResolve ? p : resolve.call(this, p);
 }
 /**
  * Normalizes options

package/dist/vfs/acl.js

@@ -44,9 +44,9 @@ import { err } from 'kerium/log';
 import { packed, sizeof } from 'memium';
 import { $from, struct, types as t } from 'memium/decorators';
 import { BufferView } from 'utilium/buffer.js';
-import { defaultContext } from '../internal/contexts.js';
-import { Attributes } from '../internal/inode.js';
 import { R_OK, S_IRWXG, S_IRWXO, S_IRWXU, W_OK, X_OK } from '../constants.js';
+import { contextOf } from '../internal/contexts.js';
+import { Attributes } from '../internal/inode.js';
 import * as xattr from './xattr.js';
 const version = 2;
 export var Type;
@@ -206,7 +206,7 @@ export function check($, inode, access) {
     if (!shouldCheck)
         return true;
     inode.attributes ??= new Attributes();
-    const { euid, egid } = $?.credentials ?? defaultContext.credentials;
+    const { euid, egid } = contextOf($).credentials;
     const data = inode.attributes.get('system.posix_acl_access');
     if (!data)
         return true;

package/dist/vfs/async.js

@@ -1,7 +1,7 @@
 import { setUVMessage, UV } from 'kerium';
 import { decodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
-import { defaultContext } from '../internal/contexts.js';
+import { contextOf } from '../internal/contexts.js';
 import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
 import { basename, dirname, join, parse, resolve as resolvePath } from '../path.js';
 import { normalizeMode, normalizePath } from '../utils.js';
@@ -17,6 +17,7 @@ import { emitChange } from './watchers.js';
  * @internal @hidden
  */
 export async function resolve($, path, preserveSymlinks, extra) {
+    path = resolvePath.call($, path);
     if (preserveSymlinks) {
         const resolved = resolveMount(path, $, extra);
         const stats = await resolved.fs.stat(resolved.path).catch(() => undefined);
@@ -74,7 +75,7 @@ export async function open($, path, opt) {
             throw UV('ENOTDIR', 'open', dirname(path));
         if (!opt.allowDirectory && mode & constants.S_IFDIR)
             throw UV('EISDIR', 'open', path);
-        const { euid: uid, egid: gid } = $?.credentials ?? defaultContext.credentials;
+        const { euid: uid, egid: gid } = contextOf($).credentials;
         const inode = await fs.createFile(resolved, {
             mode,
             uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
@@ -110,7 +111,7 @@ export async function readlink(path) {
 }
 export async function mkdir(path, options = {}) {
     path = normalizePath(path);
-    const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
+    const { euid: uid, egid: gid } = contextOf(this).credentials;
     const { mode = 0o777, recursive } = options;
     const { fs, path: resolved } = resolveMount(path, this, { syscall: 'mkdir' });
     const __create = async (path, resolved, parent) => {

package/dist/vfs/file.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { UV, withErrno } from 'kerium';
 import * as c from '../constants.js';
-import { defaultContext } from '../internal/contexts.js';
+import { contextOf } from '../internal/contexts.js';
 import { _chown, InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
 import '../polyfills.js';
 /**
@@ -371,7 +371,7 @@ export class Handle {
  * @internal @hidden
  */
 export function toFD(file) {
-    const map = file.context?.descriptors ?? defaultContext.descriptors;
+    const map = contextOf(file.context).descriptors;
     const fd = Math.max(map.size ? Math.max(...map.keys()) + 1 : 0, 4);
     map.set(fd, file);
     return fd;
@@ -380,12 +380,12 @@ export function toFD(file) {
  * @internal @hidden
  */
 export function fromFD($, fd) {
-    const map = $?.descriptors ?? defaultContext.descriptors;
+    const map = contextOf($).descriptors;
     const value = map.get(fd);
     if (!value)
         throw withErrno('EBADF');
     return value;
 }
 export function deleteFD($, fd) {
-    return ($?.descriptors ?? defaultContext.descriptors).delete(fd);
+    return contextOf($).descriptors.delete(fd);
 }

package/dist/vfs/shared.js

@@ -4,7 +4,7 @@ import { Errno, Exception, UV, withErrno } from 'kerium';
 import { alert, debug, err, info, notice, warn } from 'kerium/log';
 import { InMemory } from '../backends/memory.js';
 import { size_max } from '../constants.js';
-import { defaultContext } from '../internal/contexts.js';
+import { contextOf } from '../internal/contexts.js';
 import { credentialsAllowRoot } from '../internal/credentials.js';
 import { withExceptionContext } from '../internal/error.js';
 import { join, resolve } from '../path.js';
@@ -53,9 +53,10 @@ export function umount(mountPoint) {
  * @internal @hidden
  */
 export function resolveMount(path, ctx, extra) {
-    const root = ctx?.root || defaultContext.root;
+    const { root } = contextOf(ctx);
     const _exceptionContext = { path, ...extra };
-    path = normalizePath(join(root, path));
+    path = normalizePath(join(root, path), true);
+    path = resolve.call(ctx, path);
     const sortedMounts = [...mounts].sort((a, b) => (a[0].length > b[0].length ? -1 : 1)); // descending order of the string length
     for (const [mountPoint, fs] of sortedMounts) {
         // We know path is normalized, so it would be a substring of the mount point.
@@ -94,7 +95,7 @@ export function _statfs(fs, bigint) {
  * @category Backends and Configuration
  */
 export function chroot(path) {
-    const $ = this ?? defaultContext;
+    const $ = contextOf(this);
     if (!credentialsAllowRoot($.credentials))
         throw withErrno('EPERM', 'Can not chroot() as non-root user');
     $.root ??= '/';

package/dist/vfs/sync.js

@@ -1,7 +1,7 @@
 import { setUVMessage, UV } from 'kerium';
 import { decodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
-import { defaultContext } from '../internal/contexts.js';
+import { contextOf } from '../internal/contexts.js';
 import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
 import { basename, dirname, join, parse, resolve as resolvePath } from '../path.js';
 import { normalizeMode, normalizePath } from '../utils.js';
@@ -18,6 +18,7 @@ import { emitChange } from './watchers.js';
  * @internal @hidden
  */
 export function resolve($, path, preserveSymlinks, extra) {
+    path = resolvePath.call($, path);
     /* Try to resolve it directly. If this works,
     that means we don't need to perform any resolution for parent directories. */
     try {
@@ -87,7 +88,7 @@ export function open(path, opt) {
         if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
             throw UV('EACCES', 'open', path);
         }
-        const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
+        const { euid: uid, egid: gid } = contextOf(this).credentials;
         const inode = fs.createFileSync(resolved, {
             mode,
             uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
@@ -124,7 +125,7 @@ export function readlink(path) {
 export function mkdir(path, options = {}) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolve(this, path);
-    const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
+    const { euid: uid, egid: gid } = contextOf(this).credentials;
     const { mode = 0o777, recursive } = options;
     const __create = (path, resolved, parent) => {
         if (checkAccess && !hasAccess(this, parent, constants.W_OK))

package/dist/vfs/watchers.d.ts

@@ -75,5 +75,5 @@ export declare function removeWatcher(path: string, watcher: FSWatcher): void;
 /**
  * @internal @hidden
  */
-export declare function emitChange($: V_Context, eventType: fs.WatchEventType, filename: string): void;
+export declare function emitChange(context: V_Context, eventType: fs.WatchEventType, filename: string): void;
 export {};

package/dist/vfs/watchers.js

@@ -1,9 +1,10 @@
 import { EventEmitter } from 'eventemitter3';
 import { UV } from 'kerium';
-import { basename, dirname, join, relative } from '../path.js';
-import { normalizePath } from '../utils.js';
+import { contextOf } from '../internal/contexts.js';
 import { isStatsEqual } from '../node/stats.js';
 import { statSync } from '../node/sync.js';
+import { basename, dirname, join, relative } from '../path.js';
+import { normalizePath } from '../utils.js';
 /**
  * Base class for file system watchers.
  * Provides event handling capabilities for watching file system changes.
@@ -61,9 +62,10 @@ export class FSWatcher extends Watcher {
     options;
     realpath;
     constructor(context, path, options) {
-        super(context, path);
+        const $ = contextOf(context);
+        super($, path);
         this.options = options;
-        this.realpath = context?.root ? join(context.root, path) : path;
+        this.realpath = join($.root, path);
         addWatcher(this.realpath, this);
     }
     close() {
@@ -145,7 +147,8 @@ export function removeWatcher(path, watcher) {
 /**
  * @internal @hidden
  */
-export function emitChange($, eventType, filename) {
+export function emitChange(context, eventType, filename) {
+    const $ = contextOf(context);
     if ($)
         filename = join($.root ?? '/', filename);
     filename = normalizePath(filename);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.4.2",
+	"version": "2.4.4",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/tests/backend/single-buffer.test.ts

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert';
+import { randomBytes } from 'node:crypto';
 import { suite, test } from 'node:test';
 import { Worker } from 'worker_threads';
-import { fs, mount, resolveMountConfig, SingleBuffer } from '@zenfs/core';
+import { fs, mount, resolveMountConfig, SingleBuffer, vfs } from '@zenfs/core';
 import { setupLogs } from '../logs.js';
 
 setupLogs();
@@ -51,4 +52,50 @@ await suite('SingleBuffer', () => {
 
 		assert(fs.existsSync('/shared/worker-file.ts'));
 	});
+
+	test('reliability across varied file sizes', async () => {
+		const mountPoint = '/sbfs-reliability';
+		const verifyMountPoint = '/sbfs-verify';
+		const buffer = new ArrayBuffer(0x400000);
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer, label: 'reliability' });
+		mount(mountPoint, writable);
+
+		const filePath = `${mountPoint}/payload.bin`;
+		const growthSizes = [0, 1, 17, 512, 8192, 65535, 262144, 524288];
+		const shrinkSizes = [262144, 4096, 128, 0];
+
+		const verifySnapshot = async (expected: Buffer, size: number) => {
+			mount(verifyMountPoint, writable);
+			try {
+				const reopened = fs.readFileSync(`${verifyMountPoint}/payload.bin`);
+				assert.strictEqual(reopened.byteLength, size, `snapshot size mismatch for ${size} bytes`);
+				assert.deepStrictEqual(reopened, expected, `snapshot content mismatch for ${size} bytes`);
+			} finally {
+				vfs.umount(verifyMountPoint);
+			}
+		};
+
+		try {
+			for (const size of growthSizes) {
+				const payload = size ? randomBytes(size) : Buffer.alloc(0);
+				fs.writeFileSync(filePath, payload);
+				const direct = fs.readFileSync(filePath);
+				assert.strictEqual(direct.byteLength, size, `direct size mismatch for ${size} bytes`);
+				assert.deepStrictEqual(direct, payload, `direct content mismatch for ${size} bytes`);
+				await verifySnapshot(direct, size);
+			}
+
+			for (const size of shrinkSizes) {
+				const payload = size ? randomBytes(size) : Buffer.alloc(0);
+				fs.writeFileSync(filePath, payload);
+				const direct = fs.readFileSync(filePath);
+				assert.strictEqual(direct.byteLength, size, `direct size mismatch after shrink to ${size} bytes`);
+				assert.deepStrictEqual(direct, payload, `direct content mismatch after shrink to ${size} bytes`);
+				await verifySnapshot(direct, size);
+			}
+		} finally {
+			if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+			vfs.umount(mountPoint);
+		}
+	});
 });

package/tests/common/context.test.ts

@@ -60,8 +60,7 @@ suite('Context', () => {
 		await promise;
 	});
 
-	test('Path resolution of / with context root and mount point being the same', async () => {
-		// @zenfs/core#226
+	test('Path resolution of / with context root and mount point being the same #226', async () => {
 		await configure({
 			mounts: { '/bananas': InMemory },
 		});
@@ -73,8 +72,7 @@ suite('Context', () => {
 		assert.deepEqual(bananas.fs.readdirSync('/'), ['yellow']);
 	});
 
-	test('Different working directory', { todo: true }, () => {
-		// @zenfs/core#263
+	test('Different working directory #263', () => {
 		ctx.mkdirSync('/test');
 		context.pwd = '/test';
 

package/tests/fs/links.test.ts

@@ -19,8 +19,7 @@ suite('Links', () => {
 		assert(stats.isSymbolicLink());
 	});
 
-	test('lstat file inside symlinked directory', async () => {
-		// @zenfs/core#241
+	test('lstat file inside symlinked directory #241', async () => {
 		await fs.promises.mkdir('/a');
 		await fs.promises.writeFile('/a/hello.txt', 'hello world');
 		await fs.promises.symlink('/a', '/b');

package/tests/fs/read.test.ts

@@ -70,8 +70,7 @@ suite('read', () => {
 		assert.equal(bytesRead, expected.length);
 	});
 
-	test('read using callback API', async () => {
-		// @zenfs/core#239
+	test('read using callback API #239', async () => {
 		const path = '/text.txt';
 
 		fs.writeFileSync(path, 'hello world');