@zenfs/core 2.7.6 → 2.8.0

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

@@ -123,7 +123,7 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     protected findInodeSync(tx: WrappedTransaction, path: string): Inode;
     private _lastID?;
     /** Allocates a new ID and adds the ID/path */
-    protected allocNew(path: string): number;
+    protected allocNew(path: string): [number, number];
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
      * Note: This will commit the transaction.

package/dist/backends/store/fs.js

@@ -93,9 +93,7 @@ export class StoreFS extends FileSystem {
      * Add a inode/path pair
      */
     _add(ino, path) {
-        if (!this._paths.has(ino))
-            this._paths.set(ino, new Set());
-        this._paths.get(ino).add(path);
+        this._paths.getOrInsertComputed(ino, () => new Set()).add(path);
         this._ids.set(path, ino);
     }
     /**
@@ -618,13 +616,20 @@ export class StoreFS extends FileSystem {
             const tx = __addDisposableResource(env_17, this.transaction(), true);
             const inode = await this.findInode(tx, path);
             const end = offset + data.byteLength;
-            let buffer = data;
             if (!tx.flag('partial')) {
-                buffer = extendBuffer((await tx.get(inode.data)) ?? new Uint8Array(), end);
+                const buffer = extendBuffer((await tx.get(inode.data)) ?? new Uint8Array(), end);
                 buffer.set(data, offset);
-                offset = 0;
+                await tx.set(inode.data, buffer);
+            }
+            else if (offset <= inode.size) {
+                await tx.set(inode.data, data, offset);
+            }
+            else {
+                // Writes past the end of the file also zero the bytes before them
+                const extended = new Uint8Array(end - inode.size);
+                extended.set(data, offset - inode.size);
+                await tx.set(inode.data, extended, inode.size);
             }
-            await tx.set(inode.data, buffer, offset);
             // Update the inode in the same transaction, so data and metadata can not get out of sync (#286)
             inode.update({ size: Math.max(inode.size, end), mtimeMs: Date.now() });
             await tx.set(inode.ino, inode);
@@ -647,13 +652,20 @@ export class StoreFS extends FileSystem {
             const tx = __addDisposableResource(env_18, this.transaction(), false);
             const inode = this.findInodeSync(tx, path);
             const end = offset + data.byteLength;
-            let buffer = data;
             if (!tx.flag('partial')) {
-                buffer = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array(), end);
+                const buffer = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array(), end);
                 buffer.set(data, offset);
-                offset = 0;
+                tx.setSync(inode.data, buffer);
+            }
+            else if (offset <= inode.size) {
+                tx.setSync(inode.data, data, offset);
+            }
+            else {
+                // Writes past the end of the file also zero the bytes before them
+                const extended = new Uint8Array(end - inode.size);
+                extended.set(data, offset - inode.size);
+                tx.setSync(inode.data, extended, inode.size);
             }
-            tx.setSync(inode.data, buffer, offset);
             // Update the inode in the same transaction, so data and metadata can not get out of sync (#286)
             inode.update({ size: Math.max(inode.size, end), mtimeMs: Date.now() });
             tx.setSync(inode.ino, inode);
@@ -917,6 +929,11 @@ export class StoreFS extends FileSystem {
     _lastID;
     /** Allocates a new ID and adds the ID/path */
     allocNew(path) {
+        if (this.store.allocId) {
+            const ids = this.store.allocId();
+            this._add(ids[0], path);
+            return ids;
+        }
         // @todo use `Iterator` helper #296
         this._lastID ||= Array.from(this._paths.keys()).reduce((max, ino) => Math.max(max, ino), 0);
         this._lastID += 2;
@@ -924,7 +941,7 @@ export class StoreFS extends FileSystem {
         if (id > size_max)
             throw err(withErrno('ENOSPC', 'No IDs available'));
         this._add(id, path);
-        return id;
+        return [id, id + 1];
     }
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
@@ -949,11 +966,11 @@ export class StoreFS extends FileSystem {
             const listing = decodeDirListing((await tx.get(parent.data)) ?? _throw(withErrno('ENOENT')));
             if (listing[fname])
                 throw withErrno('EEXIST');
-            const id = this.allocNew(path);
+            const [ino, dataId] = this.allocNew(path);
             const inode = new Inode({
                 ...options,
-                ino: id,
-                data: id + 1,
+                ino,
+                data: dataId,
                 size: data.byteLength,
                 nlink: 1,
             });
@@ -998,11 +1015,11 @@ export class StoreFS extends FileSystem {
             const listing = decodeDirListing(tx.getSync(parent.data) ?? _throw(withErrno('ENOENT')));
             if (listing[fname])
                 throw withErrno('EEXIST');
-            const id = this.allocNew(path);
+            const [ino, dataId] = this.allocNew(path);
             const inode = new Inode({
                 ...options,
-                ino: id,
-                data: id + 1,
+                ino,
+                data: dataId,
                 size: data.byteLength,
                 nlink: 1,
             });

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

@@ -6,9 +6,9 @@ import { AsyncTransaction, SyncTransaction } from './store.js';
  */
 export interface SyncMapStore extends Store {
     keys(): Iterable<number>;
-    get(id: number): Uint8Array | undefined;
-    getAsync?(id: number): Promise<Uint8Array | undefined>;
-    set(id: number, data: Uint8Array): void;
+    get(id: number, offset?: number, end?: number): Uint8Array | undefined;
+    getAsync?(id: number, offset?: number, end?: number): Promise<Uint8Array | undefined>;
+    set(id: number, data: Uint8Array, offset?: number): void;
     delete(id: number): void;
 }
 /**
@@ -19,9 +19,9 @@ export interface SyncMapStore extends Store {
 export declare class SyncMapTransaction extends SyncTransaction<SyncMapStore> {
     readonly store: SyncMapStore;
     keys(): Promise<Iterable<number>>;
-    get(id: number): Promise<Uint8Array | undefined>;
-    getSync(id: number): Uint8Array | undefined;
-    setSync(id: number, data: Uint8Array): void;
+    get(id: number, offset?: number, end?: number): Promise<Uint8Array | undefined>;
+    getSync(id: number, offset?: number, end?: number): Uint8Array | undefined;
+    setSync(id: number, data: Uint8Array, offset?: number): void;
     removeSync(id: number): void;
 }
 /**

package/dist/backends/store/map.js

@@ -9,14 +9,14 @@ export class SyncMapTransaction extends SyncTransaction {
     async keys() {
         return this.store.keys();
     }
-    async get(id) {
-        return await (this.store.getAsync?.(id) ?? this.store.get(id));
+    async get(id, offset, end) {
+        return await (this.store.getAsync?.(id, offset, end) ?? this.store.get(id, offset, end));
     }
-    getSync(id) {
-        return this.store.get(id);
+    getSync(id, offset, end) {
+        return this.store.get(id, offset, end);
     }
-    setSync(id, data) {
-        this.store.set(id, data);
+    setSync(id, data, offset) {
+        this.store.set(id, data, offset);
     }
     removeSync(id) {
         this.store.delete(id);

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

@@ -7,7 +7,7 @@ import type { StoreFS } from './fs.js';
  * @category Stores and Transactions
  */
 export type StoreFlag = 
-/** The store supports partial reads and writes */
+/** The store supports reading ranges and writing at offsets */
 'partial';
 /**
  * Represents a key-value store.
@@ -48,6 +48,10 @@ export interface Store {
      * Usage information for the store
      */
     usage?(): UsageInfo;
+    /**
+     * Allocate IDs for a new inode + data
+     */
+    allocId?(): [ino: number, data: number];
     /**
      * @internal @hidden
      */
@@ -77,17 +81,17 @@ export declare abstract class Transaction<T extends Store = Store> {
      */
     abstract getSync(id: number, offset: number, end?: number): Uint8Array | undefined;
     /**
-     * Adds the data to the store under an id. Overwrites any existing data.
-     * @param id The key to add the data under.
-     * @param data The data to add to the store.
+     * Stores data under an id.
+     * Without `offset`, replaces any existing data.
+     * With `offset`, writes the data at `offset` and keeps the rest, which partial stores must support.
      */
-    abstract set(id: number, data: Uint8Array, offset: number): Promise<void>;
+    abstract set(id: number, data: Uint8Array, offset?: number): Promise<void>;
     /**
-     * Adds the data to the store under and id.
-     * @param id The key to add the data under.
-     * @param data The data to add to the store.
+     * Stores data under an id.
+     * Without `offset`, replaces any existing data.
+     * With `offset`, writes the data at `offset` and keeps the rest, which partial stores must support.
      */
-    abstract setSync(id: number, data: Uint8Array, offset: number): void;
+    abstract setSync(id: number, data: Uint8Array, offset?: number): void;
     /**
      * Deletes the data at `ino`.
      * @param id The key to delete from the store.
@@ -105,7 +109,7 @@ export declare abstract class Transaction<T extends Store = Store> {
  */
 export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
     get(id: number, offset: number, end?: number): Promise<Uint8Array | undefined>;
-    set(id: number, data: Uint8Array, offset: number): Promise<void>;
+    set(id: number, data: Uint8Array, offset?: number): Promise<void>;
     remove(id: number): Promise<void>;
 }
 /**
@@ -136,7 +140,7 @@ export declare abstract class AsyncTransaction<T extends AsyncStore = AsyncStore
         size: number;
     }): Resource<number> | undefined;
     getSync(id: number, offset: number, end?: number): Uint8Array | undefined;
-    setSync(id: number, data: Uint8Array, offset: number): void;
+    setSync(id: number, data: Uint8Array, offset?: number): void;
     removeSync(id: number): void;
 }
 /**
@@ -160,7 +164,7 @@ export declare class WrappedTransaction<T extends Store = Store> {
      */
     protected originalData: Map<number, {
         data?: Uint8Array;
-        offset: number;
+        offset?: number;
     }[]>;
     /**
      * List of keys modified in this transaction, if any.
@@ -189,9 +193,9 @@ export declare class WrappedTransaction<T extends Store = Store> {
     /**
      * Marks an id as modified, and stashes its value if it has not been stashed already.
      */
-    protected markModified(id: number, offset: number, length?: number): Promise<void>;
+    protected markModified(id: number, offset?: number, length?: number): Promise<void>;
     /**
      * Marks an id as modified, and stashes its value if it has not been stashed already.
      */
-    protected markModifiedSync(id: number, offset: number, length?: number): void;
+    protected markModifiedSync(id: number, offset?: number, length?: number): void;
 }

package/dist/backends/store/store.js

@@ -126,22 +126,22 @@ export class WrappedTransaction {
         this.stash(id);
         return data;
     }
-    async set(id, view, offset = 0) {
+    async set(id, view, offset) {
         await this.markModified(id, offset, view.byteLength);
         const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
         await this.raw.set(id, buffer, offset);
     }
-    setSync(id, view, offset = 0) {
+    setSync(id, view, offset) {
         this.markModifiedSync(id, offset, view.byteLength);
         const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
         this.raw.setSync(id, buffer, offset);
     }
     async remove(id) {
-        await this.markModified(id, 0, undefined);
+        await this.markModified(id);
         await this.raw.remove(id);
     }
     removeSync(id) {
-        this.markModifiedSync(id, 0, undefined);
+        this.markModifiedSync(id);
         this.raw.removeSync(id);
     }
     commit() {
@@ -201,19 +201,17 @@ export class WrappedTransaction {
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    stash(id, data, offset = 0) {
-        if (!this.originalData.has(id))
-            this.originalData.set(id, []);
-        this.originalData.get(id).push({ data, offset });
+    stash(id, data, offset) {
+        this.originalData.getOrInsertComputed(id, () => []).push({ data, offset });
     }
     /**
      * Marks an id as modified, and stashes its value if it has not been stashed already.
      */
     async markModified(id, offset, length) {
         this.modifiedKeys.add(id);
-        const end = length ? offset + length : undefined;
+        const end = offset !== undefined && length ? offset + length : undefined;
         try {
-            this.stash(id, await this.raw.get(id, offset, end), offset);
+            this.stash(id, await this.raw.get(id, offset ?? 0, end), offset);
         }
         catch (e) {
             if (!(this.raw instanceof AsyncTransaction))
@@ -227,7 +225,7 @@ export class WrappedTransaction {
             const resource = tx._cached(id);
             if (!resource)
                 throw e;
-            for (const range of resource.cached(offset, end ?? offset)) {
+            for (const range of resource.cached(offset ?? 0, end ?? offset ?? 0)) {
                 this.stash(id, await this.raw.get(id, range.start, range.end), range.start);
             }
         }
@@ -237,9 +235,9 @@ export class WrappedTransaction {
      */
     markModifiedSync(id, offset, length) {
         this.modifiedKeys.add(id);
-        const end = length ? offset + length : undefined;
+        const end = offset !== undefined && length ? offset + length : undefined;
         try {
-            this.stash(id, this.raw.getSync(id, offset, end), offset);
+            this.stash(id, this.raw.getSync(id, offset ?? 0, end), offset);
         }
         catch (e) {
             if (!(this.raw instanceof AsyncTransaction))
@@ -253,7 +251,7 @@ export class WrappedTransaction {
             const resource = tx._cached(id);
             if (!resource)
                 throw e;
-            for (const range of resource.cached(offset, end ?? offset)) {
+            for (const range of resource.cached(offset ?? 0, end ?? offset ?? 0)) {
                 this.stash(id, this.raw.getSync(id, range.start, range.end), range.start);
             }
         }

package/dist/config.d.ts

@@ -72,6 +72,12 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     disableAccessChecks: boolean;
+    /**
+     * If true, path resolution always walks each directory in a path, checking search permission on each.
+     * This is more correct but can be much slower.
+     * @default false
+     */
+    resolveFullWalk: boolean;
     /**
      * If true, files will only sync to the file system when closed.
      * This overrides `disableUpdateOnRead`
@@ -79,6 +85,7 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * This can increase performance.
      * @experimental
      * @default false
+     * @deprecated Replaced by the `Sync` inode flag in v2.0.0
      */
     onlySyncOnClose: boolean;
     /**

package/dist/config.js

@@ -6,7 +6,7 @@ import { DeviceFS } from './internal/devices.js';
 import { FileSystem } from './internal/filesystem.js';
 import { exists, mkdir, stat } from './node/promises.js';
 import { existsSync, mkdirSync, statSync } from './node/sync.js';
-import { _setAccessChecks } from './vfs/config.js';
+import { _setVFSConfig } from './vfs/config.js';
 import { mount, umount } from './vfs/shared.js';
 /**
  * Update the configuration of a file system.
@@ -209,7 +209,10 @@ export async function configure(configuration) {
         uid: configuration.uid || 0,
         gid: configuration.gid || 0,
     }));
-    _setAccessChecks(!configuration.disableAccessChecks);
+    _setVFSConfig({
+        checkAccess: !configuration.disableAccessChecks,
+        resolveFullWalk: !!configuration.resolveFullWalk,
+    });
     if (configuration.log)
         log.configure(configuration.log);
     if (configuration.mounts) {
@@ -257,7 +260,10 @@ export function configureSync(configuration) {
         uid: configuration.uid || 0,
         gid: configuration.gid || 0,
     }));
-    _setAccessChecks(!configuration.disableAccessChecks);
+    _setVFSConfig({
+        checkAccess: !configuration.disableAccessChecks,
+        resolveFullWalk: !!configuration.resolveFullWalk,
+    });
     if (configuration.log)
         log.configure(configuration.log);
     if (configuration.mounts) {

package/dist/internal/contexts.d.ts

@@ -28,6 +28,8 @@ export interface FSContext {
     pwd: string;
     /** The credentials of the context, used for access checks */
     readonly credentials: Credentials;
+    /** Permission bits cleared from the mode of newly created files and directories */
+    umask: number;
     /** A map of open file descriptors to their handles */
     readonly descriptors: Map<number, Handle>;
     /** The parent context, if any. */
@@ -66,6 +68,7 @@ export interface ContextInit {
     root?: string;
     pwd?: string;
     credentials?: CredentialsInit;
+    umask?: number;
     mounts?: Record<string, FileSystem>;
 }
 /**
@@ -75,6 +78,8 @@ export interface ContextInit {
  */
 export declare const defaultContext: FSContext;
 export declare function contextOf($: unknown): FSContext;
+/** Clears the permission bits of `mode` that are set in the context's umask. */
+export declare function applyUmask($: unknown, mode: number): number;
 /**
  * Create a blank FS Context
  * @internal

package/dist/internal/contexts.js

@@ -26,6 +26,7 @@ export const defaultContext = {
     root: '/',
     pwd: '/',
     credentials: createCredentials({ uid: 0, gid: 0 }),
+    umask: 0,
     descriptors: new Map(),
     parent: null,
     children: [],
@@ -34,6 +35,10 @@ export const defaultContext = {
 export function contextOf($) {
     return isContext($) ? $ : defaultContext;
 }
+/** Clears the permission bits of `mode` that are set in the context's umask. */
+export function applyUmask($, mode) {
+    return mode & ~(contextOf($).umask & 0o777);
+}
 // 1 is reserved for the global/default context
 let _nextId = 2;
 /**
@@ -46,13 +51,14 @@ let _nextId = 2;
  */
 export function createChildContext(parent, init = {}) {
     assertContext(parent);
-    const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials), mounts } = init;
+    const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials), umask = parent.umask, mounts } = init;
     const ctx = {
         [kIsContext]: true,
         id: _nextId++,
         root,
         pwd,
         credentials: createCredentials(credentials),
+        umask,
         descriptors: new Map(),
         parent: parent,
         children: [],

package/dist/internal/error.d.ts

@@ -25,3 +25,8 @@ export declare function wrap<const FS, const Prop extends keyof FS & string>(fs:
  * Wraps an `fs` so that thrown errors aren't empty
  */
 export declare function withExceptionContext<const FS extends FileSystem>(fs: FS, context: ExceptionExtra): FS;
+/**
+ * @internal
+ * Returns the file system wrapped by {@link withExceptionContext}, or `fs` if it is not wrapped
+ */
+export declare function withoutExceptionContext<const FS extends FileSystem>(fs: FS): FS;

package/dist/internal/error.js

@@ -26,6 +26,7 @@ export function wrap(fs, prop, path, dest) {
         }
     };
 }
+const kTarget = Symbol('withExceptionContext:target');
 /**
  * @internal
  * Wraps an `fs` so that thrown errors aren't empty
@@ -33,6 +34,8 @@ export function wrap(fs, prop, path, dest) {
 export function withExceptionContext(fs, context) {
     return new Proxy(fs, {
         get(target, prop) {
+            if (prop === kTarget)
+                return target;
             const value = Reflect.get(target, prop);
             if (typeof value != 'function')
                 return value;
@@ -58,3 +61,10 @@ export function withExceptionContext(fs, context) {
         },
     });
 }
+/**
+ * @internal
+ * Returns the file system wrapped by {@link withExceptionContext}, or `fs` if it is not wrapped
+ */
+export function withoutExceptionContext(fs) {
+    return fs[kTarget] ?? fs;
+}

package/dist/internal/inode.d.ts

@@ -1,3 +1,4 @@
+import { type ExceptionExtra } from 'kerium';
 import { BufferView } from 'utilium/buffer';
 import { Stats } from '../node/stats.js';
 import { type V_Context } from './contexts.js';
@@ -234,10 +235,34 @@ export declare function isFIFO(metadata: {
  * @internal
  */
 export declare function hasAccess($: V_Context, inode: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, access: number): boolean;
+/**
+ * Throws if a given user may not search the directory `dir`
+ * @internal
+ */
+export declare function assertSearchable($: V_Context, dir: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user may not remove `entry` from the directory `parent`
+ * @internal
+ */
+export declare function assertRemovable($: V_Context, parent: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, entry: Pick<InodeLike, 'uid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user is neither root nor the owner of `inode`
+ * @internal
+ */
+export declare function assertOwner($: V_Context, inode: Pick<InodeLike, 'uid'>, extra?: ExceptionExtra): void;
+/**
+ * Throws if a given user may not change the owner of `inode` to `uid` and `gid`, where `-1` leaves an ID unchanged
+ * @internal
+ */
+export declare function assertCanChown($: V_Context, inode: Pick<InodeLike, 'uid' | 'gid'>, uid: number, gid: number, extra?: ExceptionExtra): void;
 /**
  * @hidden @internal
  *
  * @todo https://github.com/nodejs/node/pull/58836 support -1 for `*chown`
  */
 export declare function _chown(stats: Partial<InodeLike>, uid: number, gid: number): boolean;
+/**
+ * @hidden @internal
+ */
+export declare function _chmod($: V_Context, inode: Pick<InodeLike, 'mode' | 'gid'>, mode: number): void;
 export {};

package/dist/internal/inode.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { withErrno } from 'kerium';
+import { UV, withErrno } from 'kerium';
 import { crit, warn } from 'kerium/log';
 import { sizeof } from 'memium';
 import { $from, field, struct, types as t } from 'memium/decorators';
@@ -41,6 +41,7 @@ import { decodeUTF8, encodeUTF8, pick } from 'utilium';
 import { BufferView } from 'utilium/buffer';
 import * as c from '../constants.js';
 import { Stats } from '../node/stats.js';
+import { checkAccess } from '../vfs/config.js';
 import { contextOf } from './contexts.js';
 /**
  * Root inode
@@ -654,10 +655,10 @@ export function hasAccess($, inode, access) {
     const { credentials } = contextOf($);
     if (isSymbolicLink(inode))
         return true;
-    if (credentials.euid === 0 || credentials.egid === 0)
+    if (credentials.euid === 0)
         return !(access & c.X_OK) || isDirectory(inode) || !!(inode.mode & (c.S_IXUSR | c.S_IXGRP | c.S_IXOTH));
     let perm = 0;
-    if (credentials.uid === inode.uid) {
+    if (credentials.euid === inode.uid) {
         if (inode.mode & c.S_IRUSR)
             perm |= c.R_OK;
         if (inode.mode & c.S_IWUSR)
@@ -665,7 +666,7 @@ export function hasAccess($, inode, access) {
         if (inode.mode & c.S_IXUSR)
             perm |= c.X_OK;
     }
-    if (credentials.gid === inode.gid || credentials.groups.includes(Number(inode.gid))) {
+    else if (credentials.egid === inode.gid || credentials.groups.includes(Number(inode.gid))) {
         if (inode.mode & c.S_IRGRP)
             perm |= c.R_OK;
         if (inode.mode & c.S_IWGRP)
@@ -673,14 +674,64 @@ export function hasAccess($, inode, access) {
         if (inode.mode & c.S_IXGRP)
             perm |= c.X_OK;
     }
-    if (inode.mode & c.S_IROTH)
-        perm |= c.R_OK;
-    if (inode.mode & c.S_IWOTH)
-        perm |= c.W_OK;
-    if (inode.mode & c.S_IXOTH)
-        perm |= c.X_OK;
+    else {
+        if (inode.mode & c.S_IROTH)
+            perm |= c.R_OK;
+        if (inode.mode & c.S_IWOTH)
+            perm |= c.W_OK;
+        if (inode.mode & c.S_IXOTH)
+            perm |= c.X_OK;
+    }
     return (perm & access) === access;
 }
+/**
+ * Throws if a given user may not search the directory `dir`
+ * @internal
+ */
+export function assertSearchable($, dir, extra) {
+    if (checkAccess && !hasAccess($, dir, c.X_OK))
+        throw UV('EACCES', extra);
+}
+/**
+ * Throws if a given user may not remove `entry` from the directory `parent`
+ * @internal
+ */
+export function assertRemovable($, parent, entry, extra) {
+    if (!checkAccess)
+        return;
+    if (!hasAccess($, parent, c.W_OK | c.X_OK))
+        throw UV('EACCES', extra);
+    const { euid } = contextOf($).credentials;
+    if (parent.mode & c.S_ISVTX && euid !== 0 && euid !== entry.uid && euid !== parent.uid)
+        throw UV('EPERM', extra);
+}
+/**
+ * Throws if a given user is neither root nor the owner of `inode`
+ * @internal
+ */
+export function assertOwner($, inode, extra) {
+    if (!checkAccess)
+        return;
+    const { euid } = contextOf($).credentials;
+    if (euid !== 0 && euid !== inode.uid)
+        throw UV('EPERM', extra);
+}
+/**
+ * Throws if a given user may not change the owner of `inode` to `uid` and `gid`, where `-1` leaves an ID unchanged
+ * @internal
+ */
+export function assertCanChown($, inode, uid, gid, extra) {
+    if (!checkAccess)
+        return;
+    const { euid, egid, groups } = contextOf($).credentials;
+    if (euid === 0)
+        return;
+    const isOwner = euid === inode.uid;
+    if (uid !== -1 && !(isOwner && uid === inode.uid))
+        throw UV('EPERM', extra);
+    if (gid !== -1 && !(isOwner && (gid === inode.gid || gid === egid || groups.includes(gid))))
+        throw UV('EPERM', extra);
+}
 /**
  * @hidden @internal
  *
@@ -696,5 +747,19 @@ export function _chown(stats, uid, gid) {
         stats.gid = gid;
     else
         valid = false;
+    if (stats.mode !== undefined && !isDirectory({ mode: stats.mode })) {
+        stats.mode &= ~c.S_ISUID;
+        if (stats.mode & c.S_IXGRP)
+            stats.mode &= ~c.S_ISGID;
+    }
     return valid;
 }
+/**
+ * @hidden @internal
+ */
+export function _chmod($, inode, mode) {
+    const { euid, egid, groups } = contextOf($).credentials;
+    if (checkAccess && euid !== 0 && egid !== inode.gid && !groups.includes(inode.gid))
+        mode &= ~c.S_ISGID;
+    inode.mode = (inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+}