@archildata/just-bash 0.1.9 → 0.1.11

package/README.md

@@ -1,6 +1,6 @@
 # @archildata/just-bash
 
-Archil filesystem adapter for [just-bash](https://github.com/anthropics/just-bash) - run bash commands against Archil distributed filesystems.
+Archil filesystem adapter for [just-bash](https://www.npmjs.com/package/just-bash) - run bash commands against Archil distributed filesystems.
 
 Launch an interactive shell against your Archil disk:
 
@@ -130,7 +130,6 @@ new ArchilFs(client: ArchilClient, options?: { user?: UnixUser })
 
 #### Utilities
 - `resolveInodeId(path)` - Get inode ID for delegation operations
-- `clearCache()` - Clear path cache
 
 ## Debugging
 
@@ -146,7 +145,6 @@ DEBUG=archil:* node myapp.js
 
 ## Performance
 
-- **Path-to-inode caching** - Avoids repeated directory lookups
 - **Chunked reads** - Large files read in 4 MiB chunks
 - **Native protocol** - Direct Archil protocol access, no FUSE overhead
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@archildata/just-bash",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Archil filesystem adapter for just-bash",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
   "bin": {

package/dist/index.d.mts

@@ -1,185 +0,0 @@
-import * as _archil_node from '@archil/node';
-import { ArchilClient, UnixUser } from '@archil/node';
-
-/**
- * Archil filesystem adapter for just-bash
- *
- * Implements the IFileSystem interface from just-bash using the ArchilClient
- * from @archil/node for direct protocol access to Archil distributed filesystems.
- */
-
-type BufferEncoding = "utf8" | "utf-8" | "ascii" | "binary" | "base64" | "hex" | "latin1";
-type FileContent = string | Uint8Array;
-interface FsStat {
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isSymlink(): boolean;
-    mode: number;
-    size: number;
-    mtimeMs: number;
-    atimeMs: number;
-    ctimeMs: number;
-    birthtimeMs: number;
-}
-interface DirentEntry {
-    name: string;
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isSymlink(): boolean;
-}
-interface IFileSystem {
-    readFile(path: string, encoding?: BufferEncoding): Promise<string>;
-    readFileBuffer(path: string): Promise<Uint8Array>;
-    readdir(path: string): Promise<string[]>;
-    readdirWithFileTypes?(path: string): Promise<DirentEntry[]>;
-    stat(path: string): Promise<FsStat>;
-    lstat(path: string): Promise<FsStat>;
-    exists(path: string): Promise<boolean>;
-    readlink(path: string): Promise<string>;
-    realpath(path: string): Promise<string>;
-    writeFile(path: string, content: FileContent): Promise<void>;
-    appendFile(path: string, content: FileContent): Promise<void>;
-    mkdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    rm(path: string, options?: {
-        recursive?: boolean;
-        force?: boolean;
-    }): Promise<void>;
-    cp(src: string, dest: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    mv(src: string, dest: string): Promise<void>;
-    symlink(target: string, path: string): Promise<void>;
-    link(existingPath: string, newPath: string): Promise<void>;
-    chmod(path: string, mode: number): Promise<void>;
-    utimes(path: string, atime: number, mtime: number): Promise<void>;
-    resolvePath(base: string, ...paths: string[]): string;
-    getAllPaths?(): Promise<string[]>;
-}
-/**
- * ArchilFs implements the just-bash IFileSystem interface using Archil protocol.
- *
- * This adapter provides:
- * - Path-to-inode resolution with caching
- * - Full filesystem operations via Archil protocol
- * - Optional user context for permission checks
- *
- * @example
- * ```typescript
- * import { ArchilClient } from '@archil/node';
- * import { ArchilFs } from '@archil/just-bash';
- *
- * const client = await ArchilClient.connectAuthenticated({
- *   mountServer: 'mount.archil.com:443',
- *   mountName: 'myaccount/mydisk',
- * });
- *
- * const fs = new ArchilFs(client);
- *
- * // Use with just-bash
- * import { Bash } from 'just-bash';
- * const bash = new Bash({ fs });
- * await bash.run('ls -la /');
- * ```
- */
-declare class ArchilFs implements IFileSystem {
-    private client;
-    private inodeCache;
-    private user?;
-    private rootInodeId;
-    /**
-     * Create a new ArchilFs adapter
-     *
-     * @param client - Connected ArchilClient instance
-     * @param options - Optional configuration
-     * @param options.user - Unix user context for permission checks
-     */
-    constructor(client: ArchilClient, options?: {
-        user?: UnixUser;
-    });
-    /**
-     * Normalize a path (remove . and .., ensure leading /)
-     */
-    private normalizePath;
-    /**
-     * Resolve a path to its inode ID, walking the directory tree
-     */
-    private resolve;
-    /**
-     * Resolve parent directory and get child name
-     */
-    private resolveParent;
-    /**
-     * Invalidate cache entries for a path and its descendants
-     */
-    private invalidateCache;
-    /**
-     * Convert InodeAttributes to FsStat
-     */
-    private toStat;
-    resolvePath(base: string, ...paths: string[]): string;
-    readFile(path: string, encoding?: BufferEncoding): Promise<string>;
-    readFileBuffer(path: string): Promise<Uint8Array>;
-    readdir(path: string): Promise<string[]>;
-    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
-    stat(path: string): Promise<FsStat>;
-    lstat(path: string): Promise<FsStat>;
-    exists(path: string): Promise<boolean>;
-    readlink(path: string): Promise<string>;
-    realpath(path: string): Promise<string>;
-    writeFile(path: string, content: FileContent): Promise<void>;
-    appendFile(path: string, content: FileContent): Promise<void>;
-    mkdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    private mkdirSingle;
-    rm(path: string, options?: {
-        recursive?: boolean;
-        force?: boolean;
-    }): Promise<void>;
-    cp(src: string, dest: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    mv(src: string, dest: string): Promise<void>;
-    symlink(target: string, path: string): Promise<void>;
-    link(existingPath: string, newPath: string): Promise<void>;
-    chmod(path: string, mode: number): Promise<void>;
-    utimes(path: string, atime: number, mtime: number): Promise<void>;
-    getAllPaths(): Promise<string[]>;
-    /**
-     * Clear the inode cache
-     */
-    clearCache(): void;
-    /**
-     * Get cache statistics
-     */
-    getCacheStats(): {
-        size: number;
-        paths: string[];
-    };
-}
-
-/**
- * Create an ArchilFs instance from an existing client
- *
- * This is a convenience function for creating the filesystem adapter.
- *
- * @param client - Connected ArchilClient instance
- * @param options - Optional configuration
- * @returns Configured ArchilFs instance
- *
- * @example
- * ```typescript
- * import { ArchilClient } from '@archil/node';
- * import { createArchilFs } from '@archil/just-bash';
- *
- * const client = await ArchilClient.connectAuthenticated({...});
- * const fs = createArchilFs(client, { user: { uid: 1000, gid: 1000 } });
- * ```
- */
-declare function createArchilFs(client: _archil_node.ArchilClient, options?: {
-    user?: _archil_node.UnixUser;
-}): ArchilFs;
-
-export { ArchilFs, type BufferEncoding, type DirentEntry, type FileContent, type FsStat, type IFileSystem, createArchilFs };

package/dist/index.mjs

@@ -1,522 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/ArchilFs.ts
-var ArchilFs_exports = {};
-__export(ArchilFs_exports, {
-  ArchilFs: () => ArchilFs
-});
-var ArchilFs;
-var init_ArchilFs = __esm({
-  "src/ArchilFs.ts"() {
-    "use strict";
-    ArchilFs = class {
-      client;
-      inodeCache;
-      user;
-      rootInodeId = 1;
-      /**
-       * Create a new ArchilFs adapter
-       *
-       * @param client - Connected ArchilClient instance
-       * @param options - Optional configuration
-       * @param options.user - Unix user context for permission checks
-       */
-      constructor(client, options) {
-        this.client = client;
-        this.user = options?.user;
-        this.inodeCache = /* @__PURE__ */ new Map();
-        this.inodeCache.set("/", this.rootInodeId);
-      }
-      // ========================================================================
-      // Path Resolution
-      // ========================================================================
-      /**
-       * Normalize a path (remove . and .., ensure leading /)
-       */
-      normalizePath(path) {
-        if (!path || path === "") {
-          return "/";
-        }
-        if (!path.startsWith("/")) {
-          path = "/" + path;
-        }
-        const parts = path.split("/").filter((p) => p !== "" && p !== ".");
-        const result = [];
-        for (const part of parts) {
-          if (part === "..") {
-            result.pop();
-          } else {
-            result.push(part);
-          }
-        }
-        return "/" + result.join("/");
-      }
-      /**
-       * Resolve a path to its inode ID, walking the directory tree
-       */
-      async resolve(path) {
-        const normalizedPath = this.normalizePath(path);
-        const cachedInode = this.inodeCache.get(normalizedPath);
-        if (cachedInode !== void 0) {
-          const attributes2 = await this.client.getAttributes(cachedInode, this.user);
-          return { inodeId: cachedInode, attributes: attributes2 };
-        }
-        const parts = normalizedPath.split("/").filter((p) => p !== "");
-        let currentInodeId = this.rootInodeId;
-        let currentPath = "";
-        for (const part of parts) {
-          currentPath += "/" + part;
-          const cached = this.inodeCache.get(currentPath);
-          if (cached !== void 0) {
-            currentInodeId = cached;
-            continue;
-          }
-          const response = await this.client.lookupInode(currentInodeId, part, this.user);
-          if (response.inodeId === -1) {
-            throw new Error(`ENOENT: no such file or directory, '${path}'`);
-          }
-          currentInodeId = response.inodeId;
-          this.inodeCache.set(currentPath, currentInodeId);
-        }
-        const attributes = await this.client.getAttributes(currentInodeId, this.user);
-        return { inodeId: currentInodeId, attributes };
-      }
-      /**
-       * Resolve parent directory and get child name
-       */
-      async resolveParent(path) {
-        const normalizedPath = this.normalizePath(path);
-        const lastSlash = normalizedPath.lastIndexOf("/");
-        const parentPath = lastSlash === 0 ? "/" : normalizedPath.substring(0, lastSlash);
-        const name = normalizedPath.substring(lastSlash + 1);
-        const { inodeId: parentInodeId } = await this.resolve(parentPath);
-        return { parentInodeId, name };
-      }
-      /**
-       * Invalidate cache entries for a path and its descendants
-       */
-      invalidateCache(path) {
-        const normalizedPath = this.normalizePath(path);
-        for (const cachedPath of this.inodeCache.keys()) {
-          if (cachedPath === normalizedPath || cachedPath.startsWith(normalizedPath + "/")) {
-            this.inodeCache.delete(cachedPath);
-          }
-        }
-      }
-      /**
-       * Convert InodeAttributes to FsStat
-       */
-      toStat(attrs) {
-        const isFile = attrs.inodeType === "File";
-        const isDirectory = attrs.inodeType === "Directory";
-        const isSymlink = attrs.inodeType === "Symlink";
-        return {
-          isFile: () => isFile,
-          isDirectory: () => isDirectory,
-          isSymlink: () => isSymlink,
-          mode: attrs.mode,
-          size: Number(attrs.size),
-          mtimeMs: attrs.mtimeMs,
-          atimeMs: attrs.atimeMs,
-          ctimeMs: attrs.ctimeMs,
-          birthtimeMs: attrs.btimeMs
-        };
-      }
-      // ========================================================================
-      // IFileSystem Implementation - Read Operations
-      // ========================================================================
-      resolvePath(base, ...paths) {
-        let result = base;
-        for (const p of paths) {
-          if (p.startsWith("/")) {
-            result = p;
-          } else {
-            result = result.endsWith("/") ? result + p : result + "/" + p;
-          }
-        }
-        return this.normalizePath(result);
-      }
-      async readFile(path, encoding) {
-        const buffer = await this.readFileBuffer(path);
-        const decoder = new TextDecoder(encoding || "utf-8");
-        return decoder.decode(buffer);
-      }
-      async readFileBuffer(path) {
-        const { inodeId, attributes } = await this.resolve(path);
-        if (attributes.inodeType !== "File") {
-          throw new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
-        }
-        const size = Number(attributes.size);
-        if (size === 0) {
-          return new Uint8Array(0);
-        }
-        const MAX_CHUNK = 4 * 1024 * 1024;
-        if (size <= MAX_CHUNK) {
-          const buffer = await this.client.readInode(inodeId, 0, size, this.user);
-          return new Uint8Array(buffer);
-        }
-        const result = new Uint8Array(size);
-        let offset = 0;
-        while (offset < size) {
-          const chunkSize = Math.min(MAX_CHUNK, size - offset);
-          const chunk = await this.client.readInode(inodeId, offset, chunkSize, this.user);
-          result.set(new Uint8Array(chunk), offset);
-          offset += chunkSize;
-        }
-        return result;
-      }
-      async readdir(path) {
-        const { inodeId, attributes } = await this.resolve(path);
-        if (attributes.inodeType !== "Directory") {
-          throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
-        }
-        const entries = await this.client.readDirectory(inodeId, void 0, void 0, this.user);
-        return entries.map((e) => e.name).filter((name) => name !== "." && name !== "..");
-      }
-      async readdirWithFileTypes(path) {
-        const { inodeId, attributes } = await this.resolve(path);
-        if (attributes.inodeType !== "Directory") {
-          throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
-        }
-        const entries = await this.client.readDirectory(inodeId, void 0, void 0, this.user);
-        return entries.filter((e) => e.name !== "." && e.name !== "..").map((e) => ({
-          name: e.name,
-          isFile: () => e.inodeType === "File",
-          isDirectory: () => e.inodeType === "Directory",
-          isSymlink: () => e.inodeType === "Symlink"
-        }));
-      }
-      async stat(path) {
-        const { attributes } = await this.resolve(path);
-        if (attributes.inodeType === "Symlink" && attributes.symlinkTarget) {
-          const targetPath = attributes.symlinkTarget.startsWith("/") ? attributes.symlinkTarget : this.resolvePath(path, "..", attributes.symlinkTarget);
-          return this.stat(targetPath);
-        }
-        return this.toStat(attributes);
-      }
-      async lstat(path) {
-        const { attributes } = await this.resolve(path);
-        return this.toStat(attributes);
-      }
-      async exists(path) {
-        try {
-          await this.resolve(path);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      async readlink(path) {
-        const { attributes } = await this.resolve(path);
-        if (attributes.inodeType !== "Symlink") {
-          throw new Error(`EINVAL: invalid argument, readlink '${path}'`);
-        }
-        return attributes.symlinkTarget || "";
-      }
-      async realpath(path) {
-        const normalizedPath = this.normalizePath(path);
-        const parts = normalizedPath.split("/").filter((p) => p !== "");
-        let resolvedPath = "/";
-        let currentInodeId = this.rootInodeId;
-        for (const part of parts) {
-          const response = await this.client.lookupInode(currentInodeId, part, this.user);
-          if (response.inodeId === -1) {
-            throw new Error(`ENOENT: no such file or directory, realpath '${path}'`);
-          }
-          const attrs = response.attributes;
-          if (attrs.inodeType === "Symlink" && attrs.symlinkTarget) {
-            const targetPath = attrs.symlinkTarget.startsWith("/") ? attrs.symlinkTarget : this.resolvePath(resolvedPath, attrs.symlinkTarget);
-            const resolved = await this.realpath(targetPath);
-            resolvedPath = resolved;
-            const { inodeId } = await this.resolve(resolved);
-            currentInodeId = inodeId;
-          } else {
-            resolvedPath = resolvedPath === "/" ? "/" + part : resolvedPath + "/" + part;
-            currentInodeId = response.inodeId;
-          }
-        }
-        return resolvedPath;
-      }
-      // ========================================================================
-      // IFileSystem Implementation - Write Operations
-      // ========================================================================
-      async writeFile(path, content) {
-        const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
-        let inodeId;
-        let isNewFile = false;
-        try {
-          const resolved = await this.resolve(path);
-          inodeId = resolved.inodeId;
-          if (resolved.attributes.inodeType !== "File") {
-            throw new Error(`EISDIR: illegal operation on a directory, write '${path}'`);
-          }
-          await this.client.checkout(inodeId, false, this.user);
-        } catch (err) {
-          if (err instanceof Error && err.message.includes("EISDIR")) {
-            throw err;
-          }
-          const { parentInodeId, name } = await this.resolveParent(path);
-          const range = await this.client.reserveInodes(1);
-          inodeId = range.start;
-          const now = Date.now();
-          await this.client.conditionalCreate(
-            parentInodeId,
-            name,
-            inodeId,
-            {
-              inodeId: Number(inodeId),
-              inodeType: "File",
-              size: 0,
-              uid: this.user?.uid ?? 0,
-              gid: this.user?.gid ?? 0,
-              mode: 420,
-              nlink: 1,
-              ctimeMs: now,
-              atimeMs: now,
-              mtimeMs: now,
-              btimeMs: now,
-              rdev: void 0,
-              symlinkTarget: void 0
-            },
-            this.user
-          );
-          this.inodeCache.set(this.normalizePath(path), inodeId);
-          isNewFile = true;
-        }
-        try {
-          await this.client.writeData(inodeId, 0, Buffer.from(data), this.user);
-        } finally {
-          if (!isNewFile) {
-            try {
-              await this.client.checkin(inodeId, this.user);
-            } catch {
-            }
-          }
-        }
-      }
-      async appendFile(path, content) {
-        let existing;
-        try {
-          existing = await this.readFileBuffer(path);
-        } catch {
-          existing = new Uint8Array(0);
-        }
-        const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
-        const combined = new Uint8Array(existing.length + data.length);
-        combined.set(existing, 0);
-        combined.set(data, existing.length);
-        await this.writeFile(path, combined);
-      }
-      async mkdir(path, options) {
-        const normalizedPath = this.normalizePath(path);
-        if (options?.recursive) {
-          const parts = normalizedPath.split("/").filter((p) => p !== "");
-          let currentPath = "";
-          for (const part of parts) {
-            currentPath += "/" + part;
-            const exists = await this.exists(currentPath);
-            if (exists) {
-              continue;
-            }
-            await this.mkdirSingle(currentPath);
-          }
-        } else {
-          await this.mkdirSingle(normalizedPath);
-        }
-      }
-      async mkdirSingle(path) {
-        const { parentInodeId, name } = await this.resolveParent(path);
-        const range = await this.client.reserveInodes(1);
-        const inodeId = range.start;
-        const now = Date.now();
-        await this.client.conditionalCreate(
-          parentInodeId,
-          name,
-          inodeId,
-          {
-            inodeId: Number(inodeId),
-            inodeType: "Directory",
-            size: 4096,
-            uid: this.user?.uid ?? 0,
-            gid: this.user?.gid ?? 0,
-            mode: 493,
-            nlink: 2,
-            ctimeMs: now,
-            atimeMs: now,
-            mtimeMs: now,
-            btimeMs: now,
-            rdev: void 0,
-            symlinkTarget: void 0
-          },
-          this.user
-        );
-        this.inodeCache.set(this.normalizePath(path), inodeId);
-      }
-      async rm(path, options) {
-        let resolved;
-        try {
-          resolved = await this.resolve(path);
-        } catch {
-          if (options?.force) {
-            return;
-          }
-          throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
-        }
-        if (resolved.attributes.inodeType === "Directory") {
-          if (!options?.recursive) {
-            throw new Error(`EISDIR: illegal operation on a directory, rm '${path}'`);
-          }
-          const entries = await this.readdir(path);
-          for (const entry of entries) {
-            await this.rm(this.resolvePath(path, entry), options);
-          }
-        }
-        const { parentInodeId, name } = await this.resolveParent(path);
-        await this.client.unlink(parentInodeId, name, this.user);
-        this.invalidateCache(path);
-      }
-      async cp(src, dest, options) {
-        const srcResolved = await this.resolve(src);
-        if (srcResolved.attributes.inodeType === "Directory") {
-          if (!options?.recursive) {
-            throw new Error(`EISDIR: illegal operation on a directory, cp '${src}'`);
-          }
-          await this.mkdir(dest, { recursive: true });
-          const entries = await this.readdir(src);
-          for (const entry of entries) {
-            await this.cp(
-              this.resolvePath(src, entry),
-              this.resolvePath(dest, entry),
-              options
-            );
-          }
-        } else {
-          const content = await this.readFileBuffer(src);
-          await this.writeFile(dest, content);
-        }
-      }
-      async mv(src, dest) {
-        const srcResolved = await this.resolve(src);
-        if (srcResolved.attributes.inodeType === "Directory") {
-          await this.cp(src, dest, { recursive: true });
-        } else {
-          const content = await this.readFileBuffer(src);
-          await this.writeFile(dest, content);
-        }
-        await this.rm(src, { recursive: true, force: true });
-      }
-      async symlink(target, path) {
-        const { parentInodeId, name } = await this.resolveParent(path);
-        const range = await this.client.reserveInodes(1);
-        const inodeId = range.start;
-        const now = Date.now();
-        await this.client.conditionalCreate(
-          parentInodeId,
-          name,
-          inodeId,
-          {
-            inodeId: Number(inodeId),
-            inodeType: "Symlink",
-            size: target.length,
-            uid: this.user?.uid ?? 0,
-            gid: this.user?.gid ?? 0,
-            mode: 511,
-            nlink: 1,
-            ctimeMs: now,
-            atimeMs: now,
-            mtimeMs: now,
-            btimeMs: now,
-            rdev: void 0,
-            symlinkTarget: target
-          },
-          this.user
-        );
-        this.inodeCache.set(this.normalizePath(path), inodeId);
-      }
-      async link(existingPath, newPath) {
-        throw new Error(
-          "Hard link operations not yet implemented. The archil-node bindings need to expose link for hard links."
-        );
-      }
-      async chmod(path, mode) {
-        throw new Error(
-          "chmod not yet implemented. The archil-node bindings need to expose setattr for permission changes."
-        );
-      }
-      async utimes(path, atime, mtime) {
-        throw new Error(
-          "utimes not yet implemented. The archil-node bindings need to expose setattr for timestamp changes."
-        );
-      }
-      // ========================================================================
-      // Utility Methods
-      // ========================================================================
-      async getAllPaths() {
-        const paths = [];
-        const walk = async (dirPath) => {
-          paths.push(dirPath);
-          try {
-            const entries = await this.readdirWithFileTypes(dirPath);
-            for (const entry of entries) {
-              const fullPath = this.resolvePath(dirPath, entry.name);
-              if (entry.isDirectory()) {
-                await walk(fullPath);
-              } else {
-                paths.push(fullPath);
-              }
-            }
-          } catch {
-          }
-        };
-        await walk("/");
-        return paths;
-      }
-      /**
-       * Clear the inode cache
-       */
-      clearCache() {
-        this.inodeCache.clear();
-        this.inodeCache.set("/", this.rootInodeId);
-      }
-      /**
-       * Get cache statistics
-       */
-      getCacheStats() {
-        return {
-          size: this.inodeCache.size,
-          paths: Array.from(this.inodeCache.keys())
-        };
-      }
-    };
-  }
-});
-
-// src/index.ts
-init_ArchilFs();
-function createArchilFs(client, options) {
-  const { ArchilFs: ArchilFs2 } = (init_ArchilFs(), __toCommonJS(ArchilFs_exports));
-  return new ArchilFs2(client, options);
-}
-export {
-  ArchilFs,
-  createArchilFs
-};