@zenfs/core 0.9.7 → 0.10.0

package/dist/emulation/promises.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer';
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
@@ -10,18 +10,10 @@ import { cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from '.
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export class FileHandle {
-    constructor(
-    /**
-     * Gets the file descriptor for this file handle.
-     */
-    fd) {
-        this.fd = fd;
-    }
-    /**
-     * @internal
-     */
-    get file() {
-        return fd2file(this.fd);
+    constructor(fdOrFile) {
+        const isFile = typeof fdOrFile != 'number';
+        this.fd = isFile ? file2fd(fdOrFile) : fdOrFile;
+        this.file = isFile ? fdOrFile : fd2file(fdOrFile);
     }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
@@ -36,7 +28,7 @@ export class FileHandle {
     chmod(mode) {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0) {
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid mode.');
+            throw new ErrnoError(Errno.EINVAL, 'Invalid mode.');
         }
         return this.file.chmod(numMode);
     }
@@ -59,7 +51,7 @@ export class FileHandle {
     truncate(len) {
         len || (len = 0);
         if (len < 0) {
-            throw new ApiError(ErrorCode.EINVAL);
+            throw new ErrnoError(Errno.EINVAL);
         }
         return this.file.truncate(len);
     }
@@ -85,10 +77,10 @@ export class FileHandle {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = parseFlag(options.flag);
         if (!isAppendable(flag)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
         }
         if (typeof data != 'string' && !options.encoding) {
-            throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length, null);
@@ -107,11 +99,11 @@ export class FileHandle {
         }
         return this.file.read(buffer, offset, length, position);
     }
-    async readFile(_options = {}) {
+    async readFile(_options) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = parseFlag(options.flag);
         if (!isReadable(flag)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading.');
         }
         const { size } = await this.stat();
         const data = new Uint8Array(size);
@@ -145,7 +137,7 @@ export class FileHandle {
                     enqueue(result.buffer.slice(0, result.bytesRead));
                     position += result.bytesRead;
                     if (++i >= maxChunks) {
-                        throw new ApiError(ErrorCode.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
+                        throw new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
                     }
                     bytesRead = result.bytesRead;
                 }
@@ -157,7 +149,7 @@ export class FileHandle {
         return new globalThis.ReadableStream({ start, type: options.type });
     }
     readLines(options) {
-        throw ApiError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
+        throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
     }
     [Symbol.asyncDispose]() {
         return this.close();
@@ -202,10 +194,10 @@ export class FileHandle {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
         const flag = parseFlag(options.flag);
         if (!isWriteable(flag)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for writing.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing.');
         }
         if (typeof data != 'string' && !options.encoding) {
-            throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length, 0);
@@ -292,31 +284,6 @@ export class FileHandle {
         return stream;
     }
 }
-/**
- * Utility for FS ops. It handles
- * - path normalization (for the first parameter to the FS op)
- * - path translation for errors
- * - FS/mount point resolution
- *
- * It can't be used for functions which may operate on multiple mounted FSs or paths (e.g. `rename`)
- * @param name the function name
- * @param resolveSymlinks whether to resolve symlinks
- * @param args the rest of the parameters are passed to the FS function. Note that the first parameter is required to be a path
- * @returns
- */
-async function doOp(...[name, resolveSymlinks, rawPath, ...args]) {
-    rawPath = normalizePath(rawPath);
-    const _path = resolveSymlinks && (await exists(rawPath)) ? await realpath(rawPath) : rawPath;
-    const { fs, path } = resolveMount(_path);
-    try {
-        // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-        return fs[name](path, ...args);
-    }
-    catch (e) {
-        throw fixError(e, { [path]: rawPath });
-    }
-}
-// fs.promises
 /**
  * Renames a file
  * @param oldPath
@@ -342,28 +309,42 @@ export async function rename(oldPath, newPath) {
 rename;
 /**
  * Test whether or not the given path exists by checking with the file system.
- * @param _path
+ * @param path
  */
-export async function exists(_path) {
+export async function exists(path) {
     try {
-        const { fs, path } = resolveMount(await realpath(_path));
-        return await fs.exists(path, cred);
+        const { fs, path: resolved } = resolveMount(await realpath(path));
+        return await fs.exists(resolved, cred);
     }
     catch (e) {
-        if (e.errno == ErrorCode.ENOENT) {
+        if (e instanceof ErrnoError && e.code == 'ENOENT') {
             return false;
         }
         throw e;
     }
 }
 export async function stat(path, options) {
-    const stats = await doOp('stat', true, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
+    try {
+        const stats = await fs.stat(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 stat;
 export async function lstat(path, options) {
-    const stats = await doOp('stat', false, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        const stats = await fs.stat(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 lstat;
 // FILE-ONLY METHODS
@@ -387,19 +368,29 @@ truncate;
  * @param path
  */
 export async function unlink(path) {
-    return doOp('unlink', false, path.toString(), cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        await fs.unlink(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 unlink;
 /**
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
  */
-async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
-    const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
+async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
+    path = normalizePath(path);
+    const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
+    path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
     try {
         switch (pathExistsAction(flag)) {
             case ActionType.THROW:
-                throw ApiError.With('EEXIST', path, '_open');
+                throw ErrnoError.With('EEXIST', path, '_open');
             case ActionType.TRUNCATE:
                 /*
                     In a previous implementation, we deleted the file and
@@ -407,33 +398,30 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
                     asynchronous request was trying to read the file, as the file
                     would not exist for a small period of time.
                 */
-                const file = await doOp('openFile', resolveSymlinks, path, flag, cred);
-                if (!file) {
-                    throw new ApiError(ErrorCode.EIO, 'Impossible code path reached');
-                }
+                const file = await fs.openFile(resolved, flag, cred);
                 await file.truncate(0);
                 await file.sync();
-                return file;
+                return new FileHandle(file);
             case ActionType.NOP:
                 // Must await so thrown errors are caught by the catch below
-                return await doOp('openFile', resolveSymlinks, path, flag, cred);
+                return new FileHandle(await fs.openFile(resolved, flag, cred));
             default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
+                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
         }
     }
     catch (e) {
         switch (pathNotExistsAction(flag)) {
             case ActionType.CREATE:
                 // Ensure parent exists.
-                const parentStats = await doOp('stat', resolveSymlinks, dirname(path), cred);
+                const parentStats = await fs.stat(dirname(resolved), cred);
                 if (parentStats && !parentStats.isDirectory()) {
-                    throw ApiError.With('ENOTDIR', dirname(path), '_open');
+                    throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
                 }
-                return await doOp('createFile', resolveSymlinks, path, flag, mode, cred);
+                return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
             case ActionType.THROW:
-                throw ApiError.With('ENOENT', path, '_open');
+                throw ErrnoError.With('ENOENT', path, '_open');
             default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
+                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
         }
     }
 }
@@ -444,36 +432,18 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
 export async function open(path, flag = 'r', mode = 0o644) {
-    const file = await _open(path, flag, mode, true);
-    return new FileHandle(file2fd(file));
+    return await _open(path, flag, mode, true);
 }
 open;
-/**
- * Asynchronously reads the entire contents of a file.
- */
-async function _readFile(fname, flag, resolveSymlinks) {
-    const file = await _open(normalizePath(fname), flag, 0o644, resolveSymlinks);
+export async function readFile(path, _options) {
+    const options = normalizeOptions(_options, null, 'r', 0o644);
+    const handle = typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode);
     try {
-        const stat = await file.stat();
-        const data = new Uint8Array(stat.size);
-        await file.read(data, 0, stat.size, 0);
-        await file.close();
-        return data;
-    }
-    catch (e) {
-        await file.close();
-        throw e;
+        return await handle.readFile(options);
     }
-}
-export async function readFile(path, _options) {
-    const options = normalizeOptions(_options, null, 'r', 0);
-    const flag = parseFlag(options.flag);
-    if (!isReadable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
+    finally {
+        await handle.close();
     }
-    path = path instanceof FileHandle ? path.file.path : path.toString();
-    const data = Buffer.from(await _readFile(path, options.flag, true));
-    return options.encoding ? data.toString(options.encoding) : data;
 }
 readFile;
 /**
@@ -493,7 +463,7 @@ export async function writeFile(path, data, _options) {
     try {
         const _data = typeof data == 'string' ? data : data;
         if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
+            throw new ErrnoError(Errno.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
         }
         await handle.writeFile(_data, options);
     }
@@ -502,19 +472,6 @@ export async function writeFile(path, data, _options) {
     }
 }
 writeFile;
-/**
- * Asynchronously append data to a file, creating the file if
- * it not yet exists.
- */
-async function _appendFile(path, data, flag, mode, resolveSymlinks) {
-    const file = await _open(path, flag, mode, resolveSymlinks);
-    try {
-        await file.write(data, 0, data.length, null);
-    }
-    finally {
-        await file.close();
-    }
-}
 /**
  * Asynchronously append data to a file, creating the file if it not yet
  * exists.
@@ -529,13 +486,19 @@ export async function appendFile(path, data, _options) {
     const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
     if (!isAppendable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
     }
     if (typeof data != 'string' && !options.encoding) {
-        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+        throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
     }
     const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    await _appendFile(path instanceof FileHandle ? path.file.path : path.toString(), encodedData, options.flag, options.mode, true);
+    const handle = typeof path == 'object' && 'fd' in path ? path : await open(path, options.flag, options.mode);
+    try {
+        await handle.appendFile(encodedData, options);
+    }
+    finally {
+        await handle.close();
+    }
 }
 appendFile;
 // DIRECTORY-ONLY METHODS
@@ -544,19 +507,41 @@ appendFile;
  * @param path
  */
 export async function rmdir(path) {
-    return doOp('rmdir', true, path.toString(), cred);
+    path = normalizePath(path);
+    path = (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        await fs.rmdir(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 rmdir;
 export async function mkdir(path, options) {
-    await doOp('mkdir', true, path.toString(), normalizeMode(typeof options == 'object' ? options?.mode : options, 0o777), cred);
-    return;
+    path = normalizePath(path);
+    path = (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        await fs.mkdir(resolved, normalizeMode(typeof options == 'object' ? options?.mode : options, 0o777), cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 mkdir;
 export async function readdir(path, options) {
     path = normalizePath(path);
-    const entries = await doOp('readdir', true, path, cred);
-    const points = [...mounts.keys()];
-    for (const point of points) {
+    path = (await exists(path)) ? await realpath(path) : path;
+    const { fs, path: resolved } = resolveMount(path);
+    let entries;
+    try {
+        entries = await fs.readdir(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
+    for (const point of mounts.keys()) {
         if (point.startsWith(path)) {
             const entry = point.slice(path.length);
             if (entry.includes('/') || entry.length == 0) {
@@ -580,8 +565,15 @@ readdir;
  * @param newpath
  */
 export async function link(existing, newpath) {
+    existing = normalizePath(existing);
     newpath = normalizePath(newpath);
-    return doOp('link', false, existing.toString(), newpath, cred);
+    const { fs, path: resolved } = resolveMount(newpath);
+    try {
+        return await fs.link(existing, newpath, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: newpath });
+    }
 }
 link;
 /**
@@ -592,20 +584,26 @@ link;
  */
 export async function symlink(target, path, type = 'file') {
     if (!['file', 'dir', 'junction'].includes(type)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
+        throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
     }
     if (await exists(path)) {
-        throw ApiError.With('EEXIST', path.toString(), 'symlink');
+        throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
     }
     await writeFile(path, target.toString());
-    const file = await _open(path, 'r+', 0o644, false);
-    await file._setType(FileType.SYMLINK);
+    const handle = await _open(path, 'r+', 0o644, false);
+    await handle.file._setType(FileType.SYMLINK);
 }
 symlink;
 export async function readlink(path, options) {
-    const value = Buffer.from(await _readFile(path.toString(), 'r', false));
-    const encoding = typeof options == 'object' ? options?.encoding : options;
-    return encoding == 'buffer' ? value : value.toString(encoding);
+    const handle = await _open(normalizePath(path), 'r', 0o644, false);
+    try {
+        const value = await handle.readFile();
+        const encoding = typeof options == 'object' ? options?.encoding : options;
+        return encoding == 'buffer' ? value : value.toString(encoding);
+    }
+    finally {
+        await handle.close();
+    }
 }
 readlink;
 // PROPERTY OPERATIONS
@@ -632,12 +630,12 @@ chown;
  * @param gid
  */
 export async function lchown(path, uid, gid) {
-    const file = await _open(path, 'r+', 0o644, false);
+    const handle = await _open(path, 'r+', 0o644, false);
     try {
-        await file.chown(uid, gid);
+        await handle.chown(uid, gid);
     }
     finally {
-        await file.close();
+        await handle.close();
     }
 }
 lchown;
@@ -662,12 +660,12 @@ chmod;
  * @param mode
  */
 export async function lchmod(path, mode) {
-    const file = await _open(path, 'r+', 0o644, false);
+    const handle = await _open(path, 'r+', 0o644, false);
     try {
-        await new FileHandle(file2fd(file)).chmod(mode);
+        await handle.chmod(mode);
     }
     finally {
-        await file.close();
+        await handle.close();
     }
 }
 lchmod;
@@ -694,12 +692,12 @@ utimes;
  * @param mtime
  */
 export async function lutimes(path, atime, mtime) {
-    const file = await _open(path, 'r+', 0o644, false);
+    const handle = await _open(path, 'r+', 0o644, false);
     try {
-        await file.utimes(new Date(atime), new Date(mtime));
+        await handle.utimes(new Date(atime), new Date(mtime));
     }
     finally {
-        await file.close();
+        await handle.close();
     }
 }
 lutimes;
@@ -721,7 +719,7 @@ export async function realpath(path, options) {
 }
 realpath;
 export function watch(filename, options = {}) {
-    throw ApiError.With('ENOSYS', filename.toString(), 'watch');
+    throw ErrnoError.With('ENOSYS', filename.toString(), 'watch');
 }
 watch;
 /**
@@ -732,7 +730,7 @@ watch;
 export async function access(path, mode = constants.F_OK) {
     const stats = await stat(path);
     if (!stats.hasAccess(mode, cred)) {
-        throw new ApiError(ErrorCode.EACCES);
+        throw new ErrnoError(Errno.EACCES);
     }
 }
 access;
@@ -761,7 +759,7 @@ export async function rm(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            throw new ApiError(ErrorCode.EPERM, 'File type not supported', path, 'rm');
+            throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
 }
 rm;
@@ -784,7 +782,7 @@ export async function copyFile(src, dest, mode) {
     src = normalizePath(src);
     dest = normalizePath(dest);
     if (mode && mode & constants.COPYFILE_EXCL && (await exists(dest))) {
-        throw new ApiError(ErrorCode.EEXIST, 'Destination file already exists.', dest, 'copyFile');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
     }
     await writeFile(dest, await readFile(src));
 }
@@ -817,12 +815,12 @@ export async function cp(source, destination, opts) {
     destination = normalizePath(destination);
     const srcStats = await lstat(source); // Use lstat to follow symlinks if not dereferencing
     if (opts?.errorOnExist && (await exists(destination))) {
-        throw new ApiError(ErrorCode.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
     }
     switch (srcStats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (!opts?.recursive) {
-                throw new ApiError(ErrorCode.EISDIR, source + ' is a directory (not copied)', source, 'cp');
+                throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
             }
             await mkdir(destination, { recursive: true }); // Ensure the destination directory exists
             for (const dirent of await readdir(source, { withFileTypes: true })) {
@@ -841,7 +839,7 @@ export async function cp(source, destination, opts) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            throw new ApiError(ErrorCode.EPERM, 'File type not supported', source, 'rm');
+            throw new ErrnoError(Errno.EPERM, 'File type not supported', source, 'rm');
     }
     // Optionally preserve timestamps
     if (opts?.preserveTimestamps) {
@@ -850,5 +848,5 @@ export async function cp(source, destination, opts) {
 }
 cp;
 export async function statfs(path, opts) {
-    throw ApiError.With('ENOSYS', path.toString(), 'statfs');
+    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
 }

package/dist/emulation/shared.d.ts

@@ -1,14 +1,13 @@
 import { Cred } from '../cred.js';
 import type { File } from '../file.js';
 import { FileSystem } from '../filesystem.js';
+import { type AbsolutePath } from './path.js';
 export declare let cred: Cred;
 export declare function setCred(val: Cred): void;
 export declare const fdMap: Map<number, File>;
 export declare function file2fd(file: File): number;
 export declare function fd2file(fd: number): File;
-export interface MountMapping {
-    [point: string]: FileSystem;
-}
+export type MountObject = Record<AbsolutePath, FileSystem>;
 /**
  * The map of mount points
  * @internal
@@ -33,10 +32,6 @@ export declare function resolveMount(path: string): {
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
  */
-export declare function fixPaths(text: string, paths: {
-    [from: string]: string;
-}): string;
-export declare function fixError<E extends Error>(e: E, paths: {
-    [from: string]: string;
-}): E;
-export declare function mountMapping(mountMapping: MountMapping): void;
+export declare function fixPaths(text: string, paths: Record<string, string>): string;
+export declare function fixError<E extends Error>(e: E, paths: Record<string, string>): E;
+export declare function mountObject(mounts: MountObject): void;

package/dist/emulation/shared.js

@@ -1,5 +1,5 @@
 // Utilities and shared data
-import { ApiError, ErrorCode } from '../ApiError.js';
+import { ErrnoError, Errno } from '../error.js';
 import { InMemory } from '../backends/InMemory.js';
 import { rootCred } from '../cred.js';
 import { normalizePath } from '../utils.js';
@@ -19,7 +19,7 @@ export function file2fd(file) {
 }
 export function fd2file(fd) {
     if (!fdMap.has(fd)) {
-        throw new ApiError(ErrorCode.EBADF);
+        throw new ErrnoError(Errno.EBADF);
     }
     return fdMap.get(fd);
 }
@@ -41,7 +41,7 @@ export function mount(mountPoint, fs) {
     }
     mountPoint = resolve(mountPoint);
     if (mounts.has(mountPoint)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
+        throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
     }
     mounts.set(mountPoint, fs);
 }
@@ -54,7 +54,7 @@ export function umount(mountPoint) {
     }
     mountPoint = resolve(mountPoint);
     if (!mounts.has(mountPoint)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
+        throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
     }
     mounts.delete(mountPoint);
 }
@@ -74,7 +74,7 @@ export function resolveMount(path) {
             return { fs, path, mountPoint };
         }
     }
-    throw new ApiError(ErrorCode.EIO, 'ZenFS not initialized with a file system');
+    throw new ErrnoError(Errno.EIO, 'ZenFS not initialized with a file system');
 }
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
@@ -92,11 +92,11 @@ export function fixError(e, paths) {
     e.message = fixPaths(e.message, paths);
     return e;
 }
-export function mountMapping(mountMapping) {
-    if ('/' in mountMapping) {
+export function mountObject(mounts) {
+    if ('/' in mounts) {
         umount('/');
     }
-    for (const [point, fs] of Object.entries(mountMapping)) {
+    for (const [point, fs] of Object.entries(mounts)) {
         mount(point, fs);
     }
 }