@zenfs/core 2.6.5 → 2.7.0

package/dist/backends/cow.js

@@ -11,7 +11,8 @@ const journalOperations = new Set(['delete']);
 function isJournalOp(op) {
     return journalOperations.has(op);
 }
-const maxOpLength = Math.max(...[...journalOperations].map(op => op.length));
+// @todo use `Iterator` helper #296
+const maxOpLength = [...journalOperations].reduce((max, op) => Math.max(max, op.length), 0);
 const journalMagicString = '#journal@v0\n';
 /**
  * Tracks various operations for the CoW backend
@@ -450,7 +451,7 @@ export class CopyOnWriteFS extends FileSystem {
         if (size)
             this.readable.readSync(path, data, 0, size);
         this.writable.createFileSync(path, stats);
-        this.writable.touchSync(path, stats);
+        this.writable.touchSync(path, { ...pick(stats, _inode_fields), attributes: stats.attributes, size });
         if (size)
             this.writable.writeSync(path, data, 0);
     }
@@ -468,7 +469,7 @@ export class CopyOnWriteFS extends FileSystem {
         if (size)
             await this.readable.read(path, data, 0, size);
         await this.writable.createFile(path, stats);
-        await this.writable.touch(path, stats);
+        await this.writable.touch(path, { ...pick(stats, _inode_fields), attributes: stats.attributes, size });
         if (size)
             await this.writable.write(path, data, 0);
     }

package/dist/backends/fetch.d.ts

@@ -1,6 +1,7 @@
 import type { IndexData } from '../internal/file_index.js';
 import { Index } from '../internal/file_index.js';
 import { IndexFS } from '../internal/index_fs.js';
+import type { Inode, InodeLike } from '../internal/inode.js';
 import type { SharedConfig } from './backend.js';
 /**
  * Configuration options for FetchFS.
@@ -45,6 +46,9 @@ export declare class FetchFS extends IndexFS {
      */
     protected _async(p: Promise<unknown>): void;
     constructor(index: Index, baseUrl: string, requestInit?: RequestInit, remoteWrite?: boolean | undefined);
+    protected resize(path: string, inode: Inode, oldSize: number): Promise<void> | void;
+    touch(path: string, metadata: InodeLike): Promise<void>;
+    touchSync(path: string, metadata: InodeLike): void;
     protected remove(path: string): Promise<void>;
     protected removeSync(path: string): void;
     read(path: string, buffer: Uint8Array, offset: number | undefined, end: number): Promise<void>;

package/dist/backends/fetch.js

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { debug, err, warn } from 'kerium/log';
-import { decodeUTF8 } from 'utilium';
+import { _throw, decodeUTF8 } from 'utilium';
+import { Resource } from 'utilium/cache';
 import * as requests from 'utilium/requests';
 import { Index } from '../internal/file_index.js';
 import { IndexFS } from '../internal/index_fs.js';
+import { isDirectory } from '../internal/inode.js';
 import { normalizePath } from '../utils.js';
 import { S_IFREG } from '../constants.js';
 /** Parse and throw */
@@ -48,6 +50,33 @@ export class FetchFS extends IndexFS {
         this.requestInit = requestInit;
         this.remoteWrite = remoteWrite;
     }
+    resize(path, inode, oldSize) {
+        if (isDirectory(inode) || inode.size == oldSize)
+            return;
+        const url = this.baseUrl + path;
+        const resource = requests.resourcesCache.get(url) ?? new Resource(url, oldSize, {}, requests.resourcesCache);
+        resource.size = inode.size;
+        if (inode.size < oldSize)
+            return;
+        const zeroes = new Uint8Array(inode.size - oldSize);
+        resource.add(zeroes, oldSize);
+        if (this.remoteWrite)
+            return requests.set(url, zeroes, { offset: oldSize, warn }, this.requestInit).catch(parseError);
+    }
+    async touch(path, metadata) {
+        const inode = this.index.get(path) ?? _throw(withErrno('ENOENT'));
+        const oldSize = inode.size;
+        inode.update(metadata);
+        await this.resize(path, inode, oldSize);
+    }
+    touchSync(path, metadata) {
+        const inode = this.index.get(path) ?? _throw(withErrno('ENOENT'));
+        const oldSize = inode.size;
+        inode.update(metadata);
+        const pending = this.resize(path, inode, oldSize);
+        if (pending)
+            this._async(pending);
+    }
     async remove(path) {
         await requests.remove(this.baseUrl + path, { warn, cacheOnly: !this.remoteWrite }, this.requestInit);
     }

package/dist/backends/memory.d.ts

@@ -9,7 +9,7 @@ export declare class InMemoryStore extends Map<number, Uint8Array> implements Sy
     readonly maxSize: number;
     readonly label?: string | undefined;
     readonly flags: readonly [];
-    readonly name = "tmpfs";
+    readonly name: string;
     constructor(maxSize?: number, label?: string | undefined);
     sync(): Promise<void>;
     transaction(): SyncMapTransaction;

package/dist/backends/store/fs.js

@@ -234,7 +234,7 @@ export class StoreFS extends FileSystem {
                 const [path, ino] = queue.shift();
                 const inode = new Inode(await tx.get(ino));
                 index.set(path, inode);
-                if (inode.mode & S_IFDIR) {
+                if (isDirectory(inode)) {
                     const dir = decodeDirListing((await tx.get(inode.data)) ?? _throw(withErrno('ENODATA')));
                     for (const [name, id] of Object.entries(dir)) {
                         queue.push([join(path, name), id]);
@@ -265,7 +265,7 @@ export class StoreFS extends FileSystem {
                 const [path, ino] = queue.shift();
                 const inode = new Inode(tx.getSync(ino));
                 index.set(path, inode);
-                if (inode.mode & S_IFDIR) {
+                if (isDirectory(inode)) {
                     const dir = decodeDirListing(tx.getSync(inode.data) ?? _throw(withErrno('ENODATA')));
                     for (const [name, id] of Object.entries(dir)) {
                         queue.push([join(path, name), id]);
@@ -418,6 +418,12 @@ export class StoreFS extends FileSystem {
         try {
             const tx = __addDisposableResource(env_9, this.transaction(), true);
             const inode = await this.findInode(tx, path);
+            if (!isDirectory(inode) && metadata.size !== undefined && metadata.size !== inode.size) {
+                const data = (await tx.get(inode.data)) ?? new Uint8Array();
+                if (metadata.size < data.byteLength)
+                    data.fill(0, metadata.size);
+                await tx.set(inode.data, metadata.size < data.byteLength ? data.subarray(0, metadata.size) : extendBuffer(data, metadata.size));
+            }
             if (inode.update(metadata)) {
                 this._add(inode.ino, path);
                 tx.setSync(inode.ino, inode);
@@ -439,6 +445,12 @@ export class StoreFS extends FileSystem {
         try {
             const tx = __addDisposableResource(env_10, this.transaction(), false);
             const inode = this.findInodeSync(tx, path);
+            if (!isDirectory(inode) && metadata.size !== undefined && metadata.size !== inode.size) {
+                const data = tx.getSync(inode.data) ?? new Uint8Array();
+                if (metadata.size < data.byteLength)
+                    data.fill(0, metadata.size);
+                tx.setSync(inode.data, metadata.size < data.byteLength ? data.subarray(0, metadata.size) : extendBuffer(data, metadata.size));
+            }
             if (inode.update(metadata)) {
                 this._add(inode.ino, path);
                 tx.setSync(inode.ino, inode);
@@ -768,7 +780,7 @@ export class StoreFS extends FileSystem {
                 // Parse the raw data into our Inode object
                 const inode = new Inode(inodeData);
                 // If it is a directory and not yet visited, read its directory listing
-                if ((inode.mode & S_IFDIR) != S_IFDIR || visitedDirectories.has(ino)) {
+                if (!isDirectory(inode) || visitedDirectories.has(ino)) {
                     continue;
                 }
                 visitedDirectories.add(ino);
@@ -835,7 +847,7 @@ export class StoreFS extends FileSystem {
                     continue;
                 }
                 const inode = new Inode(inodeData);
-                if ((inode.mode & S_IFDIR) != S_IFDIR || visitedDirectories.has(ino)) {
+                if (!isDirectory(inode) || visitedDirectories.has(ino)) {
                     continue;
                 }
                 visitedDirectories.add(ino);
@@ -921,7 +933,8 @@ export class StoreFS extends FileSystem {
     _lastID;
     /** Allocates a new ID and adds the ID/path */
     allocNew(path) {
-        this._lastID ??= Math.max(...this._paths.keys());
+        // @todo use `Iterator` helper #296
+        this._lastID ||= Array.from(this._paths.keys()).reduce((max, ino) => Math.max(max, ino), 0);
         this._lastID += 2;
         const id = this._lastID;
         if (id > size_max)

package/dist/config.js

@@ -7,7 +7,7 @@ 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 { mount, mounts, umount } from './vfs/shared.js';
+import { mount, umount } from './vfs/shared.js';
 /**
  * Update the configuration of a file system.
  * @category Backends and Configuration
@@ -191,7 +191,7 @@ function mountWithMkdirSync(path, fs) {
  * @category Backends and Configuration
  */
 export function addDevice(driver, options) {
-    const devfs = mounts.get('/dev');
+    const devfs = defaultContext.mounts.get('/dev');
     if (!(devfs instanceof DeviceFS))
         throw log.crit(withErrno('ENOTSUP', '/dev does not exist or is not a device file system'));
     return devfs._createDevice(driver, options);
@@ -223,10 +223,10 @@ export async function configure(configuration) {
             await mountWithMkdir(point, await resolveMountConfig(mountConfig));
         }
     }
-    for (const fs of mounts.values()) {
+    for (const fs of defaultContext.mounts.values()) {
         configureFileSystem(fs, configuration);
     }
-    if (configuration.addDevices && !mounts.has('/dev')) {
+    if (configuration.addDevices && !defaultContext.mounts.has('/dev')) {
         const devfs = new DeviceFS();
         devfs.addDefaults();
         await devfs.ready();
@@ -270,10 +270,10 @@ export function configureSync(configuration) {
             mountWithMkdirSync(point, resolveMountConfigSync(mountConfig));
         }
     }
-    for (const fs of mounts.values()) {
+    for (const fs of defaultContext.mounts.values()) {
         configureFileSystem(fs, configuration);
     }
-    if (configuration.addDevices && !mounts.has('/dev')) {
+    if (configuration.addDevices && !defaultContext.mounts.has('/dev')) {
         const devfs = new DeviceFS();
         devfs.addDefaults();
         devfs.readySync();
@@ -292,6 +292,6 @@ export function configureSync(configuration) {
     }
 }
 export async function sync() {
-    for (const fs of mounts.values())
+    for (const fs of defaultContext.mounts.values())
         await fs.sync();
 }

package/dist/internal/contexts.d.ts

@@ -4,6 +4,7 @@ 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';
+import type { FileSystem } from './filesystem.js';
 /**
  * Symbol used for context branding
  * @internal @hidden
@@ -34,6 +35,8 @@ export interface FSContext {
     readonly parent: FSContext | null;
     /** The child contexts */
     readonly children: FSContext[];
+    /** The mount table for this context */
+    readonly mounts: Map<string, FileSystem>;
 }
 export declare function isContext(obj: unknown): obj is FSContext;
 export declare function assertContext(ctx: unknown): asserts ctx is FSContext;
@@ -64,6 +67,7 @@ export interface ContextInit {
     root?: string;
     pwd?: string;
     credentials?: CredentialsInit;
+    mounts?: Record<string, FileSystem>;
 }
 /**
  * The default/global context.

package/dist/internal/contexts.js

@@ -1,6 +1,8 @@
-import { createCredentials } from './credentials.js';
-import { warn } from 'kerium/log';
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// This needs to be in a separate file to avoid circular dependencies
 import { withErrno } from 'kerium';
+import { warn } from 'kerium/log';
+import { createCredentials } from './credentials.js';
 /**
  * Symbol used for context branding
  * @internal @hidden
@@ -20,19 +22,20 @@ export function assertContext(ctx) {
  */
 export const defaultContext = {
     [kIsContext]: true,
-    id: 0,
+    id: 1,
     root: '/',
     pwd: '/',
     credentials: createCredentials({ uid: 0, gid: 0 }),
     descriptors: new Map(),
     parent: null,
     children: [],
+    mounts: new Map(),
 };
 export function contextOf($) {
     return isContext($) ? $ : defaultContext;
 }
-// 0 is reserved for the global/default context
-let _nextId = 1;
+// 1 is reserved for the global/default context
+let _nextId = 2;
 /**
  * Create a blank FS Context
  * @internal
@@ -43,7 +46,7 @@ let _nextId = 1;
  */
 export function createChildContext(parent, init = {}) {
     assertContext(parent);
-    const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials) } = init;
+    const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials), mounts = Object.fromEntries(parent.mounts), } = init;
     const ctx = {
         [kIsContext]: true,
         id: _nextId++,
@@ -53,6 +56,7 @@ export function createChildContext(parent, init = {}) {
         descriptors: new Map(),
         parent: parent,
         children: [],
+        mounts: new Map(Object.entries(mounts)),
     };
     Object.defineProperties(ctx, {
         id: { configurable: false, writable: false },

package/dist/internal/file_index.js

@@ -87,7 +87,8 @@ export class Index extends Map {
     _alloc() {
         // @todo use `Iterator.flatMap` #296
         this.#lastAlloc ||= Array.from(this.values()).reduce((max, inode) => Math.max(max, inode.ino, inode.data), 0);
-        return ++this.#lastAlloc;
+        this.#lastAlloc++;
+        return this.#lastAlloc++;
     }
     /**
      * Gets a list of entries for each directory in the index.

package/dist/internal/filesystem.d.ts

@@ -1,6 +1,7 @@
 import type { UUID } from 'node:crypto';
 import type { ConstMap } from 'utilium';
 import type { InodeLike } from './inode.js';
+import type { IoctlContext } from './ioctl.js';
 /**
  * Usage information about a file system
  * @category Internals
@@ -244,4 +245,8 @@ export declare abstract class FileSystem {
      * @privateRemarks The default implementation of `streamWrite` uses "chunked" `write`s
      */
     streamWrite(path: string, options: StreamOptions): WritableStream;
+    /** @internal */
+    ioctl(context: IoctlContext, command: number, ...args: any[]): Promise<any>;
+    /** @internal */
+    ioctlSync(context: IoctlContext, command: number, ...args: any[]): any;
 }

package/dist/internal/filesystem.js

@@ -1,4 +1,6 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
+import { ioctl_default_ops_async, ioctl_default_ops_sync } from './ioctl.js';
 const _chunkSize = 0x1000;
 /**
  * Provides a consistent and easy to use internal API.
@@ -132,4 +134,20 @@ export class FileSystem {
             },
         });
     }
+    /** @internal */
+    async ioctl(context, command, ...args) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method, @typescript-eslint/no-unnecessary-type-assertion
+        const cmd = ioctl_default_ops_async[command];
+        if (!cmd)
+            throw withErrno('ENOTTY');
+        return await cmd(this, context, ...args);
+    }
+    /** @internal */
+    ioctlSync(context, command, ...args) {
+        // eslint-disable-next-line @typescript-eslint/unbound-method, @typescript-eslint/no-unnecessary-type-assertion
+        const cmd = ioctl_default_ops_sync[command];
+        if (!cmd)
+            throw withErrno('ENOTTY');
+        return cmd(this, context, ...args);
+    }
 }

package/dist/internal/inode.d.ts

@@ -79,6 +79,10 @@ export interface InodeLike<T extends number | bigint = number> extends InodeFiel
      * Number of hard links
      */
     nlink: T;
+    /**
+     * Device ID for special files
+     */
+    rdev: T;
     /**
      * Extended attributes
      */
@@ -87,7 +91,7 @@ export interface InodeLike<T extends number | bigint = number> extends InodeFiel
 /**
  * @internal @hidden
  */
-export declare const _inode_fields: readonly ["ino", "data", "size", "mode", "flags", "nlink", "uid", "gid", "atimeMs", "birthtimeMs", "mtimeMs", "ctimeMs", "version"];
+export declare const _inode_fields: readonly ["ino", "data", "size", "mode", "flags", "nlink", "uid", "gid", "atimeMs", "birthtimeMs", "mtimeMs", "ctimeMs", "version", "rdev"];
 /**
  * Represents which version of the `Inode` format we are on.
  * 1. 58 bytes. The first member was called `ino` but used as the ID for data.
@@ -182,6 +186,7 @@ export declare class Inode extends Inode_base implements InodeLike {
      * Unrelated to the inode format!
      */
     accessor version: number;
+    accessor rdev: number;
     /**
      * Padding up to 128 bytes.
      * This ensures there is enough room for expansion without breaking the ABI.

package/dist/internal/inode.js

@@ -270,6 +270,7 @@ export const _inode_fields = [
     'mtimeMs',
     'ctimeMs',
     'version',
+    'rdev',
 ];
 /**
  * Represents which version of the `Inode` format we are on.
@@ -335,7 +336,7 @@ export const userModifiableFlags = 0x000380ff;
  * @internal
  */
 let Inode = (() => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
     let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
@@ -389,6 +390,9 @@ let Inode = (() => {
     let _version_decorators;
     let _version_initializers = [];
     let _version_extraInitializers = [];
+    let _rdev_decorators;
+    let _rdev_initializers = [];
+    let _rdev_extraInitializers = [];
     let ___padding_decorators;
     let ___padding_initializers = [];
     let ___padding_extraInitializers = [];
@@ -418,7 +422,8 @@ let Inode = (() => {
             _flags_decorators = [(_p = t).uint32.bind(_p)];
             ___after_flags_decorators = [(_q = t).uint16.bind(_q)];
             _version_decorators = [(_r = t).uint32.bind(_r)];
-            ___padding_decorators = [t.uint8(48)];
+            _rdev_decorators = [(_s = t).uint32.bind(_s)];
+            ___padding_decorators = [t.uint8(44)];
             _attributes_decorators = [field(Attributes)];
             ___data_decorators = [t.uint8(maxDynamicData)];
             __esDecorate(this, null, _data_decorators, { kind: "accessor", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
@@ -437,6 +442,7 @@ let Inode = (() => {
             __esDecorate(this, null, _flags_decorators, { kind: "accessor", name: "flags", static: false, private: false, access: { has: obj => "flags" in obj, get: obj => obj.flags, set: (obj, value) => { obj.flags = value; } }, metadata: _metadata }, _flags_initializers, _flags_extraInitializers);
             __esDecorate(this, null, ___after_flags_decorators, { kind: "accessor", name: "__after_flags", static: false, private: false, access: { has: obj => "__after_flags" in obj, get: obj => obj.__after_flags, set: (obj, value) => { obj.__after_flags = value; } }, metadata: _metadata }, ___after_flags_initializers, ___after_flags_extraInitializers);
             __esDecorate(this, null, _version_decorators, { kind: "accessor", name: "version", static: false, private: false, access: { has: obj => "version" in obj, get: obj => obj.version, set: (obj, value) => { obj.version = value; } }, metadata: _metadata }, _version_initializers, _version_extraInitializers);
+            __esDecorate(this, null, _rdev_decorators, { kind: "accessor", name: "rdev", static: false, private: false, access: { has: obj => "rdev" in obj, get: obj => obj.rdev, set: (obj, value) => { obj.rdev = value; } }, metadata: _metadata }, _rdev_initializers, _rdev_extraInitializers);
             __esDecorate(this, null, ___padding_decorators, { kind: "accessor", name: "__padding", static: false, private: false, access: { has: obj => "__padding" in obj, get: obj => obj.__padding, set: (obj, value) => { obj.__padding = value; } }, metadata: _metadata }, ___padding_initializers, ___padding_extraInitializers);
             __esDecorate(this, null, _attributes_decorators, { kind: "accessor", name: "attributes", static: false, private: false, access: { has: obj => "attributes" in obj, get: obj => obj.attributes, set: (obj, value) => { obj.attributes = value; } }, metadata: _metadata }, _attributes_initializers, _attributes_extraInitializers);
             __esDecorate(this, null, ___data_decorators, { kind: "accessor", name: "__data", static: false, private: false, access: { has: obj => "__data" in obj, get: obj => obj.__data, set: (obj, value) => { obj.__data = value; } }, metadata: _metadata }, ___data_initializers, ___data_extraInitializers);
@@ -528,7 +534,10 @@ let Inode = (() => {
          */
         get version() { return this.#version_accessor_storage; }
         set version(value) { this.#version_accessor_storage = value; }
-        #__padding_accessor_storage = (__runInitializers(this, _version_extraInitializers), __runInitializers(this, ___padding_initializers, void 0));
+        #rdev_accessor_storage = (__runInitializers(this, _version_extraInitializers), __runInitializers(this, _rdev_initializers, void 0));
+        get rdev() { return this.#rdev_accessor_storage; }
+        set rdev(value) { this.#rdev_accessor_storage = value; }
+        #__padding_accessor_storage = (__runInitializers(this, _rdev_extraInitializers), __runInitializers(this, ___padding_initializers, void 0));
         /**
          * Padding up to 128 bytes.
          * This ensures there is enough room for expansion without breaking the ABI.

package/dist/internal/ioctl.d.ts

@@ -0,0 +1,148 @@
+import { BufferView } from 'utilium/buffer';
+import type { FileSystem } from './filesystem.js';
+import type { InodeLike } from './inode.js';
+declare const fsxattr_base: import("memium").StructConstructor<BufferView<any>>;
+declare class fsxattr extends fsxattr_base {
+    static name: string;
+    /** xflags field value */
+    accessor xflags: number;
+    /** extsize field value */
+    accessor extsize: number;
+    /** nextents field value */
+    accessor nextents: number;
+    /** project identifier */
+    accessor projid: number;
+    /** CoW extsize field value */
+    accessor cowextsize: number;
+    protected accessor pad: number[];
+    constructor(inode?: Readonly<InodeLike>);
+}
+/**
+ * `FS_IOC_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export declare enum IOC {
+    GetFlags = 2148034049,
+    SetFlags = 1074292226,
+    GetVersion = 2148038145,
+    SetVersion = 1074296322,
+    Fiemap = 3223348747,
+    GetXattr = 2149341215,
+    SetXattr = 1075599392,
+    GetLabel = 2164298801,
+    SetLabel = 1090556978,
+    GetUUID = 2148603136,
+    GetSysfsPath = 2155943169
+}
+/**
+ * `FS_IOC32_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export declare enum IOC32 {
+    GetFlags = 2147771905,
+    SetFlags = 1074030082,
+    GetVersion = 2147776001,
+    SetVersion = 1074034178
+}
+/**
+ * @category ioctl
+ */
+export interface IoctlContext {
+    fs: FileSystem;
+    inode: InodeLike;
+    path: string;
+    file?: {
+        position: number;
+        flag: number;
+    };
+}
+/**
+ * @category ioctl
+ */
+export type Ioctl = (context: IoctlContext, ...args: any[]) => any;
+/**
+ * What an ioctl takes from whoever is calling it, which is everything but the context it is given.
+ * @category ioctl
+ */
+export type IoctlArgs<T extends Ioctl> = T extends (context: IoctlContext, ...args: infer A) => any ? A : never;
+/**
+ * @category ioctl
+ */
+export interface IoctlOps extends Record<number, Ioctl> {
+}
+/**
+ * @internal
+ * @category ioctl
+ */
+export declare const ioctl_default_ops: {
+    2148034049($: IoctlContext): number;
+    2147771905($: IoctlContext): number;
+    2148038145($: IoctlContext): number;
+    2147776001($: IoctlContext): number;
+    3223348747(): never;
+    2149341215($: IoctlContext, _name: string): fsxattr;
+    1075599392($: IoctlContext, _name: string, _value: fsxattr): never;
+    2164298801($: IoctlContext): string | undefined;
+    1090556978($: IoctlContext, label: string): void;
+    2148603136($: IoctlContext): string;
+    2155943169($: IoctlContext): string;
+};
+/**
+ * @internal
+ * @category ioctl
+ */
+export declare const ioctl_default_ops_async: {
+    1074292226($: IoctlContext, flags: number): Promise<void>;
+    1074030082($: IoctlContext, flags: number): Promise<void>;
+    1074296322($: IoctlContext, version: number): Promise<void>;
+    1074034178($: IoctlContext, version: number): Promise<void>;
+    2148034049($: IoctlContext): number;
+    2147771905($: IoctlContext): number;
+    2148038145($: IoctlContext): number;
+    2147776001($: IoctlContext): number;
+    3223348747(): never;
+    2149341215($: IoctlContext, _name: string): fsxattr;
+    1075599392($: IoctlContext, _name: string, _value: fsxattr): never;
+    2164298801($: IoctlContext): string | undefined;
+    1090556978($: IoctlContext, label: string): void;
+    2148603136($: IoctlContext): string;
+    2155943169($: IoctlContext): string;
+};
+type _IoctlOpsAsync = typeof ioctl_default_ops_async;
+/**
+ * @internal
+ * @category ioctl
+ */
+export interface IoctlDefaultAsyncOps extends _IoctlOpsAsync {
+}
+/**
+ * @internal
+ * @category ioctl
+ */
+export declare const ioctl_default_ops_sync: {
+    1074292226($: IoctlContext, flags: number): void;
+    1074030082($: IoctlContext, flags: number): void;
+    1074296322($: IoctlContext, version: number): void;
+    1074034178($: IoctlContext, version: number): void;
+    2148034049($: IoctlContext): number;
+    2147771905($: IoctlContext): number;
+    2148038145($: IoctlContext): number;
+    2147776001($: IoctlContext): number;
+    3223348747(): never;
+    2149341215($: IoctlContext, _name: string): fsxattr;
+    1075599392($: IoctlContext, _name: string, _value: fsxattr): never;
+    2164298801($: IoctlContext): string | undefined;
+    1090556978($: IoctlContext, label: string): void;
+    2148603136($: IoctlContext): string;
+    2155943169($: IoctlContext): string;
+};
+type _IoctlOpsSync = typeof ioctl_default_ops_sync;
+/**
+ * @internal
+ * @category ioctl
+ */
+export interface IoctlDefaultSyncOps extends _IoctlOpsSync {
+}
+export {};