@zenfs/core 2.4.3 → 2.4.4

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.3",
+	"version": "2.4.4",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

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');