opfs-worker 2.0.0 → 2.1.1

package/dist/index.pure.js

@@ -1,1056 +1,53 @@
-import { V as C, t as g, l as O, h as P, q as p, s as D, P as z, w as u, O as w, m as h, W as l, n as k, j as F, o as v, p as E, z as M, E as S, D as T, G as $, v as b, A as H, c as B, g as N, r as _, L as R, J as A, H as I, K as L, k as m, C as U } from "./helpers-WY2jfbOT.js";
-import { M as K, F as X, I as Y, a as Q, f as Z, b as tt, S as et, B as at, y as rt, d as it, e as st, x as nt, i as ot, u as ct } from "./helpers-WY2jfbOT.js";
-import { transfer as x } from "comlink";
-class V {
-  /** Root directory handle for the file system */
-  root;
-  /** Map of watched paths and options */
-  watchers = /* @__PURE__ */ new Map();
-  /** Promise to prevent concurrent mount operations */
-  mountingPromise = null;
-  /** BroadcastChannel instance for sending events */
-  broadcastChannel = null;
-  /** Configuration options */
-  options = {
-    root: "/",
-    namespace: "",
-    maxFileSize: 50 * 1024 * 1024,
-    hashAlgorithm: "etag",
-    broadcastChannel: "opfs-worker"
-  };
-  /** Shared sync handles per path (OPFS allows only one handle per file) */
-  openHandles = /* @__PURE__ */ new Map();
-  /** Map of open file descriptors to their metadata */
-  openFiles = /* @__PURE__ */ new Map();
-  /** Next available file descriptor number */
-  nextFd = 1;
-  /**
-   * Get file info by descriptor with validation
-   * @private
-   */
-  _getFileDescriptor(t) {
-    const e = this.openFiles.get(t);
-    if (!e)
-      throw new C("descriptor", `Invalid file descriptor: ${t}`);
-    return e;
-  }
-  /**
-   * Notify about internal changes to the file system
-   * 
-   * This method is called by internal operations to notify clients about
-   * changes, even when no specific paths are being watched.
-   * 
-   * @param event - The event describing the change
-   */
-  async notifyChange(t) {
-    if (!this.options.broadcastChannel)
-      return;
-    const e = t.path;
-    if (![...this.watchers.values()].some((i) => g(e, i.pattern) && i.include.some((s) => s && g(e, s)) && !i.exclude.some((s) => s && g(e, s))))
-      return;
-    let a;
-    if (this.options.hashAlgorithm)
-      try {
-        a = (await this.stat(e)).hash;
-      } catch {
-      }
-    try {
-      this.broadcastChannel || (this.broadcastChannel = new BroadcastChannel(this.options.broadcastChannel));
-      const i = {
-        namespace: this.options.namespace,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        ...t,
-        ...a && { hash: a }
-      };
-      this.broadcastChannel.postMessage(i);
-    } catch (i) {
-      console.warn("Failed to send event via BroadcastChannel:", i);
-    }
-  }
-  /**
-   * Creates a new OPFSWorker instance
-   * 
-   * @param options - Optional configuration options
-   * @param options.root - Root path for the file system (default: '/')
-   * @param options.watchInterval - Polling interval in milliseconds for file watching
-   * @param options.hashAlgorithm - Hash algorithm for file hashing
-   * @param options.maxFileSize - Maximum file size for hashing in bytes (default: 50MB)
-   * @throws {OPFSError} If OPFS is not supported in the current browser
-   */
-  constructor(t) {
-    O(), t && this.setOptions(t);
-  }
-  /**
-   * Initialize the file system within a given directory
-   * 
-   * This method sets up the root directory for all subsequent operations.
-   * If no root is specified, it will use the OPFS root directory.
-   * 
-   * @returns Promise that resolves to true if initialization was successful
-   * @throws {OPFSError} If initialization fails
-   * 
-   * @example
-   * ```typescript
-   * const fs = new OPFSWorker();
-   * 
-   * // Use OPFS root (default)
-   * await fs.mount();
-   * 
-   * // Use custom directory
-   * await fs.mount('/my-app');
-   * ```
-   */
-  async mount() {
-    const t = this.options.root;
-    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (e, r) => {
-      try {
-        const a = await navigator.storage.getDirectory();
-        this.root = t === "/" ? a : await this.getDirectoryHandle(t, !0, a), e(!0);
-      } catch (a) {
-        r(new P(t, a));
-      } finally {
-        this.mountingPromise = null;
-      }
-    }), this.mountingPromise;
-  }
-  /**
-   * Update configuration options
-   * 
-   * @param options - Configuration options to update
-   * @param options.root - Root path for the file system
-   * @param options.watchInterval - Polling interval in milliseconds for file watching
-   * @param options.hashAlgorithm - Hash algorithm for file hashing
-   * @param options.maxFileSize - Maximum file size for hashing in bytes
-   * @param options.broadcastChannel - Custom name for the broadcast channel
-   */
-  async setOptions(t) {
-    t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel), t.namespace && (this.options.namespace = t.namespace), t.root !== void 0 && (this.options.root = p(t.root), this.options.namespace || (this.options.namespace = `opfs-worker:${this.options.root}`), await this.mount());
-  }
-  /**
-   * Get a directory handle from a path
-   * 
-   * Navigates through the directory structure to find or create a directory
-   * at the specified path.
-   * 
-   * @param path - The path to the directory (string or array of segments)
-   * @param create - Whether to create the directory if it doesn't exist (default: false)
-   * @param from - The directory to start from (default: root directory)
-   * @returns Promise that resolves to the directory handle
-   * @throws {OPFSError} If the directory cannot be accessed or created
-   * 
-   * @example
-   * ```typescript
-   * const docsDir = await fs.getDirectoryHandle('/users/john/documents', true);
-   * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
-   * ```
-   */
-  async getDirectoryHandle(t, e = !1, r = this.root) {
-    const a = Array.isArray(t) ? t : D(t);
-    let i = r;
-    for (const s of a)
-      i = await i.getDirectoryHandle(s, { create: e });
-    return i;
-  }
-  /**
-   * Get a file handle from a path
-   * 
-   * Navigates to the parent directory and retrieves or creates a file handle
-   * for the specified file path.
-   * 
-   * @param path - The path to the file (string or array of segments)
-   * @param create - Whether to create the file if it doesn't exist (default: false)
-   * @param _from - The directory to start from (default: root directory)
-   * @returns Promise that resolves to the file handle
-   * @throws {PathError} If the path is empty
-   * @throws {OPFSError} If the file cannot be accessed or created
-   * 
-   * @example
-   * ```typescript
-   * const fileHandle = await fs.getFileHandle('/config/settings.json', true);
-   * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
-   * ```
-   */
-  async getFileHandle(t, e = !1, r = this.root) {
-    const a = D(t);
-    if (a.length === 0)
-      throw new z("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
-    const i = a.pop();
-    return (await this.getDirectoryHandle(a, e, r)).getFileHandle(i, { create: e });
-  }
-  /**
-   * Get a complete index of all files and directories in the file system
-   * 
-   * This method recursively traverses the entire file system and returns
-   * a Map containing FileStat objects for every file and directory.
-   * 
-   * @returns Promise that resolves to a Map of paths to FileStat objects
-   * @throws {OPFSError} If the file system is not mounted
-   * 
-   * @example
-   * ```typescript
-   * const index = await fs.index();
-   * const fileStats = index.get('/data/config.json');
-   * if (fileStats) {
-   *   console.log(`File size: ${fileStats.size} bytes`);
-   *   if (fileStats.hash) console.log(`Hash: ${fileStats.hash}`);
-   * }
-   * ```
-   */
-  async index() {
-    const t = /* @__PURE__ */ new Map(), e = async (r) => {
-      const a = await this.readDir(r);
-      for (const i of a) {
-        const s = `${r === "/" ? "" : r}/${i.name}`;
-        try {
-          const n = await this.stat(s);
-          t.set(s, n), n.isDirectory && await e(s);
-        } catch (n) {
-          console.warn(`Skipping broken entry: ${s}`, n);
-        }
-      }
-    };
-    return t.set("/", {
-      kind: "directory",
-      size: 0,
-      mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
-      ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
-      isFile: !1,
-      isDirectory: !0
-    }), await e("/"), t;
-  }
-  /**
-   * Read a file from the file system
-   * 
-   * Reads the contents of a file and returns it as binary data.
-   * 
-   * @param path - The path to the file to read
-   * @returns Promise that resolves to the file contents as Uint8Array
-   * @throws {FileNotFoundError} If the file does not exist
-   * @throws {OPFSError} If reading the file fails
-   * 
-   * @example
-   * ```typescript
-   * // Read as binary data
-   * const content = await fs.readFile('/config/settings.json');
-   * 
-   * // Read binary file
-   * const binaryData = await fs.readFile('/images/logo.png');
-   * ```
-   */
-  async readFile(t) {
-    await this.mount();
-    try {
-      return await u(t, async () => {
-        const e = await this.open(t);
-        try {
-          const { size: r } = await this.fstat(e), a = new Uint8Array(r);
-          return r > 0 && await this.read(e, a, 0, r, 0), x(a, [a.buffer]);
-        } finally {
-          await this.close(e);
-        }
-      });
-    } catch (e) {
-      throw e instanceof w ? e : h(e, { path: t, isDirectory: !1 });
-    }
-  }
-  /**
-   * Write data to a file
-   * 
-   * Creates or overwrites a file with the specified binary data. If the file already
-   * exists, it will be truncated before writing.
-   * 
-   * @param path - The path to the file to write
-   * @param data - The binary data to write to the file (Uint8Array or ArrayBuffer)
-   * @returns Promise that resolves when the write operation is complete
-   * @throws {OPFSError} If writing the file fails
-   * 
-   * @example
-   * ```typescript
-   * // Write binary data
-   * const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
-   * await fs.writeFile('/data/binary.dat', binaryData);
-   * 
-   * // Write from ArrayBuffer
-   * const arrayBuffer = new ArrayBuffer(10);
-   * await fs.writeFile('/data/buffer.dat', arrayBuffer);
-   * ```
-   */
-  async writeFile(t, e) {
-    await this.mount();
-    const r = e instanceof Uint8Array ? e : new Uint8Array(e);
-    await u(t, async () => {
-      const a = await this.exists(t), i = await this.open(t, { create: !0, truncate: !0 });
-      try {
-        await this.write(i, r, 0, r.length, null, !1), await this.fsync(i);
-      } finally {
-        await this.close(i);
-      }
-      await this.notifyChange({ path: t, type: a ? l.Changed : l.Added, isDirectory: !1 });
-    });
-  }
-  /**
-   * Append data to a file
-   * 
-   * Adds binary data to the end of an existing file. If the file doesn't exist,
-   * it will be created.
-   * 
-   * @param path - The path to the file to append to
-   * @param data - The binary data to append to the file (Uint8Array or ArrayBuffer)
-   * @returns Promise that resolves when the append operation is complete
-   * @throws {OPFSError} If appending to the file fails
-   * 
-   * @example
-   * ```typescript
-   * // Append binary data
-   * const additionalData = new Uint8Array([6, 7, 8]);
-   * await fs.appendFile('/data/binary.dat', additionalData);
-   * 
-   * // Append from ArrayBuffer
-   * const arrayBuffer = new ArrayBuffer(5);
-   * await fs.appendFile('/data/buffer.dat', arrayBuffer);
-   * ```
-   */
-  async appendFile(t, e) {
-    await this.mount();
-    const r = e instanceof Uint8Array ? e : new Uint8Array(e);
-    await u(t, async () => {
-      const a = await this.open(t, { create: !0 });
-      try {
-        const { size: i } = await this.fstat(a);
-        await this.write(a, r, 0, r.length, i, !1), await this.fsync(a);
-      } finally {
-        await this.close(a);
-      }
-      await this.notifyChange({ path: t, type: l.Changed, isDirectory: !1 });
-    });
-  }
-  /**
-   * Create a directory
-   * 
-   * Creates a new directory at the specified path. If the recursive option
-   * is enabled, parent directories will be created as needed.
-   * 
-   * @param path - The path where the directory should be created
-   * @param options - Options for directory creation
-   * @param options.recursive - Whether to create parent directories if they don't exist (default: false)
-   * @returns Promise that resolves when the directory is created
-   * @throws {OPFSError} If the directory cannot be created
-   * 
-   * @example
-   * ```typescript
-   * // Create a single directory
-   * await fs.mkdir('/users/john');
-   * 
-   * // Create nested directories
-   * await fs.mkdir('/users/john/documents/projects', { recursive: true });
-   * ```
-   */
-  async mkdir(t, e) {
-    await this.mount();
-    const r = e?.recursive ?? !1, a = D(t);
-    let i = this.root;
-    for (let s = 0; s < a.length; s++) {
-      const n = a[s];
-      try {
-        i = await i.getDirectoryHandle(n, { create: r || s === a.length - 1 });
-      } catch (o) {
-        throw o.name === "NotFoundError" ? h(o, {
-          path: k(a.slice(0, s + 1)),
-          existenceType: "directory"
-        }) : o.name === "TypeMismatchError" ? h(o, { path: n, isDirectory: !1 }) : new F("create directory", n, o);
-      }
-    }
-    await this.notifyChange({ path: t, type: l.Added, isDirectory: !0 });
-  }
-  /**
-   * Get file or directory statistics
-   * 
-   * Returns detailed information about a file or directory, including
-   * size, modification time, and optionally a hash of the file content.
-   * 
-   * @param path - The path to the file or directory
-   * @returns Promise that resolves to FileStat object
-   * @throws {OPFSError} If the path does not exist or cannot be accessed
-   * 
-   * @example
-   * ```typescript
-   * const stats = await fs.stat('/data/config.json');
-   * console.log(`File size: ${stats.size} bytes`);
-   * console.log(`Last modified: ${stats.mtime}`);
-   * 
-   * // If hashing is enabled, hash will be included
-   * if (stats.hash) {
-   *   console.log(`Hash: ${stats.hash}`);
-   * }
-   * ```
-   */
-  async stat(t) {
-    if (await this.mount(), t === "/")
-      return {
-        kind: "directory",
-        size: 0,
-        mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
-        ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
-        isFile: !1,
-        isDirectory: !0
-      };
-    const e = v(t);
-    let r;
-    try {
-      r = await this.getDirectoryHandle(E(t), !1);
-      const a = this.options.hashAlgorithm, s = await (await r.getFileHandle(e, { create: !1 })).getFile(), n = {
-        kind: "file",
-        size: s.size,
-        mtime: new Date(s.lastModified).toISOString(),
-        ctime: new Date(s.lastModified).toISOString(),
-        isFile: !0,
-        isDirectory: !1
-      };
-      if (a === "etag")
-        n.hash = `${s.lastModified.toString(36)}-${s.size.toString(36)}`;
-      else if (typeof a == "string")
-        try {
-          const o = await M(s, a, this.options.maxFileSize);
-          n.hash = o;
-        } catch (o) {
-          console.warn(`Failed to calculate hash for ${t}:`, o);
-        }
-      return n;
-    } catch (a) {
-      if (a.name === "NotFoundError")
-        throw new S("file", t, a);
-      if (a.name !== "TypeMismatchError")
-        throw new F("stat", t, a);
-    }
-    try {
-      return await r.getDirectoryHandle(e, { create: !1 }), {
-        kind: "directory",
-        size: 0,
-        mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
-        ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
-        isFile: !1,
-        isDirectory: !0
-      };
-    } catch (a) {
-      throw new F("stat", t, a);
-    }
-  }
-  /**
-   * Read a directory's contents
-   * 
-   * Lists all files and subdirectories within the specified directory.
-   * 
-   * @param path - The path to the directory to read
-   * @returns Promise that resolves to an array of detailed file/directory information
-   * @throws {OPFSError} If the directory does not exist or cannot be accessed
-   * 
-   * @example
-   * ```typescript
-   * // Get detailed information about files and directories
-   * const detailed = await fs.readDir('/users/john/documents');
-   * detailed.forEach(item => {
-   *   console.log(`${item.name} - ${item.isFile ? 'file' : 'directory'}`);
-   * });
-   * ```
-   */
-  async readDir(t) {
-    await this.mount();
-    const e = await this.getDirectoryHandle(t, !1), r = [];
-    for await (const [a, i] of e.entries()) {
-      const s = i.kind === "file";
-      r.push({
-        name: a,
-        kind: i.kind,
-        isFile: s,
-        isDirectory: !s
-      });
-    }
-    return r;
-  }
-  /**
-   * Check if a file or directory exists
-   * 
-   * Verifies if a file or directory exists at the specified path.
-   * 
-   * @param path - The path to check
-   * @returns Promise that resolves to true if the file or directory exists, false otherwise  
-   * 
-   * @example
-   * ```typescript
-   * const exists = await fs.exists('/config/settings.json');
-   * console.log(`File exists: ${exists}`);
-   * ```
-   */
-  async exists(t) {
-    if (await this.mount(), t === "/")
-      return !0;
-    const e = v(t);
-    let r = null;
-    try {
-      r = await this.getDirectoryHandle(E(t), !1);
-    } catch (a) {
-      if (r = null, a.name !== "NotFoundError" && a.name !== "TypeMismatchError")
-        throw a;
-    }
-    if (!r || !e)
-      return !1;
-    try {
-      return await r.getFileHandle(e, { create: !1 }), !0;
-    } catch (a) {
-      if (a.name !== "NotFoundError" && a.name !== "TypeMismatchError")
-        throw a;
-      try {
-        return await r.getDirectoryHandle(e, { create: !1 }), !0;
-      } catch (i) {
-        if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
-          throw i;
-        return !1;
-      }
-    }
-  }
-  /**
-   * Clear all contents of a directory without removing the directory itself
-   * 
-   * Removes all files and subdirectories within the specified directory,
-   * but keeps the directory itself.
-   * 
-   * @param path - The path to the directory to clear (default: '/')
-   * @returns Promise that resolves when all contents are removed
-   * @throws {OPFSError} If the operation fails
-   * 
-   * @example
-   * ```typescript
-   * // Clear root directory contents
-   * await fs.clear('/');
-   * 
-   * // Clear specific directory contents
-   * await fs.clear('/data');
-   * ```
-   */
-  async clear(t = "/") {
-    await this.mount();
-    try {
-      const e = await this.readDir(t);
-      for (const r of e) {
-        const a = `${t === "/" ? "" : t}/${r.name}`;
-        await this.remove(a, { recursive: !0 });
-      }
-      await this.notifyChange({ path: t, type: l.Changed, isDirectory: !0 });
-    } catch (e) {
-      throw e instanceof w ? e : h(e, { path: t, isDirectory: !0 });
-    }
-  }
-  /**
-   * Remove files and directories
-   * 
-   * Removes files and directories. Similar to Node.js fs.rm().
-   * 
-   * @param path - The path to remove
-   * @param options - Options for removal
-   * @param options.recursive - Whether to remove directories and their contents recursively (default: false)
-   * @param options.force - Whether to ignore errors if the path doesn't exist (default: false)
-   * @returns Promise that resolves when the removal is complete
-   * @throws {OPFSError} If the removal fails
-   * 
-   * @example
-   * ```typescript
-   * // Remove a file
-   * await fs.rm('/path/to/file.txt');
-   * 
-   * // Remove a directory and all its contents
-   * await fs.rm('/path/to/directory', { recursive: true });
-   * 
-   * // Remove with force (ignore if doesn't exist)
-   * await fs.rm('/maybe/exists', { force: true });
-   * ```
-   */
-  async remove(t, e) {
-    if (await this.mount(), t === "/")
-      throw new T("EROOT", t);
-    const { recursive: r = !1, force: a = !1 } = e || {}, i = await this.getDirectoryHandle(E(t), !1), s = await this.stat(t);
-    await $(i, t, { recursive: r, force: a }), await this.notifyChange({ path: t, type: l.Removed, isDirectory: s.isDirectory });
-  }
-  /**
-   * Resolve a path to an absolute path
-   * 
-   * Resolves relative paths and normalizes path segments (like '..' and '.').
-   * Similar to Node.js fs.realpath() but without symlink resolution since OPFS doesn't support symlinks.
-   * 
-   * @param path - The path to resolve
-   * @returns Promise that resolves to the absolute normalized path
-   * @throws {FileNotFoundError} If the path does not exist
-   * @throws {OPFSError} If path resolution fails
-   * 
-   * @example
-   * ```typescript
-   * // Resolve relative path
-   * const absolute = await fs.realpath('./config/../data/file.txt');
-   * console.log(absolute); // '/data/file.txt'
-   * ```
-   */
-  async realpath(t) {
-    await this.mount();
-    try {
-      const e = b(t);
-      if (!await this.exists(e))
-        throw new S("file", e);
-      return e;
-    } catch (e) {
-      throw e instanceof w ? e : h(e, { path: t });
-    }
-  }
-  /**
-   * Rename a file or directory
-   * 
-   * Changes the name of a file or directory. If the target path already exists,
-   * it will be replaced only if overwrite option is enabled.
-   * 
-   * @param oldPath - The current path of the file or directory
-   * @param newPath - The new path for the file or directory
-   * @param options - Options for renaming
-   * @param options.overwrite - Whether to overwrite existing files (default: false)
-   * @returns Promise that resolves when the rename operation is complete
-   * @throws {OPFSError} If the rename operation fails
-   * 
-   * @example
-   * ```typescript
-   * // Basic rename (fails if target exists)
-   * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
-   * 
-   * // Rename with overwrite
-   * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt', { overwrite: true });
-   * ```
-   */
-  async rename(t, e, r) {
-    await this.mount();
-    try {
-      const a = r?.overwrite ?? !1, i = await this.stat(t);
-      if (await this.exists(e) && !a)
-        throw new H(e);
-      await this.copy(t, e, { recursive: !0, overwrite: a }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: l.Removed, isDirectory: i.isDirectory }), await this.notifyChange({ path: e, type: l.Added, isDirectory: i.isDirectory });
-    } catch (a) {
-      throw a instanceof w ? a : h(a, { path: t });
-    }
-  }
-  /**
-   * Copy files and directories
-   * 
-   * Copies files and directories. Similar to Node.js fs.cp().
-   * 
-   * @param source - The source path to copy from
-   * @param destination - The destination path to copy to
-   * @param options - Options for copying
-   * @param options.recursive - Whether to copy directories recursively (default: false)
-   * @param options.overwrite - Whether to overwrite existing files (default: true)
-   * @returns Promise that resolves when the copy operation is complete
-   * @throws {OPFSError} If the copy operation fails
-   * 
-   * @example
-   * ```typescript
-   * // Copy a file
-   * await fs.copy('/source/file.txt', '/dest/file.txt');
-   * 
-   * // Copy a directory and all its contents
-   * await fs.copy('/source/dir', '/dest/dir', { recursive: true });
-   * 
-   * // Copy without overwriting existing files
-   * await fs.copy('/source', '/dest', { recursive: true, overwrite: false });
-   * ```
-   */
-  async copy(t, e, r) {
-    await this.mount();
-    try {
-      const a = r?.recursive ?? !1, i = r?.overwrite ?? !0;
-      if (!await this.exists(t))
-        throw new S("source", t);
-      if (await this.exists(e) && !i)
-        throw new H(e);
-      if ((await this.stat(t)).isFile) {
-        const c = await this.readFile(t);
-        await this.writeFile(e, c);
-      } else {
-        if (!a)
-          throw new B("directory", t);
-        await this.mkdir(e, { recursive: !0 });
-        const c = await this.readDir(t);
-        for (const y of c) {
-          const f = `${t}/${y.name}`, d = `${e}/${y.name}`;
-          await this.copy(f, d, { recursive: !0, overwrite: i });
-        }
-      }
-    } catch (a) {
-      throw a instanceof w ? a : h(a, { path: t });
-    }
-  }
-  /**
-   * Start watching a file or directory for changes
-   * 
-   * @param path - The path to watch (minimatch syntax allowed)
-   * @param options - Watch options
-   * @param options.recursive - Whether to watch recursively (default: true)
-   * @param options.exclude - Glob pattern(s) to exclude (minimatch).
-   * @returns Promise that resolves when watching starts
-   * 
-   * @example
-   * ```typescript
-   * // Watch entire directory tree recursively (default)
-   * await fs.watch('/data');
-   * 
-   * // Watch only immediate children (shallow)
-   * await fs.watch('/data', { recursive: false });
-   * 
-   * // Watch a single file
-   * await fs.watch('/config.json', { recursive: false });
-   * 
-   * // Watch all json files but not in dist directory
-   * await fs.watch('/**\/*.json', { recursive: false, exclude: ['dist/**'] });
-   *
-   * ```
-   */
-  async watch(t, e) {
-    if (!this.options.broadcastChannel)
-      throw new N("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.");
-    const r = {
-      pattern: _(t, e?.recursive ?? !0),
-      include: Array.isArray(e?.include) ? e.include : [e?.include ?? "**"],
-      exclude: Array.isArray(e?.exclude) ? e.exclude : [e?.exclude ?? ""]
-    };
-    this.watchers.set(t, r);
-  }
-  /**
-   * Stop watching a previously watched path
-   */
-  unwatch(t) {
-    this.watchers.delete(t);
-  }
-  /**
-   * Open a file and return a file descriptor
-   * 
-   * @param path - The path to the file to open
-   * @param options - Options for opening the file
-   * @param options.create - Whether to create the file if it doesn't exist (default: false)
-   * @param options.exclusive - If true and create is true, fails if file already exists (default: false)
-   *                            Note: This is best-effort in OPFS, not fully atomic due to browser limitations
-   * @param options.truncate - Whether to truncate the file to zero length (default: false)
-   * @returns Promise that resolves to a file descriptor number
-   * @throws {OPFSError} If opening the file fails
-   * 
-   * @example
-   * ```typescript
-   * // Open existing file for reading
-   * const fd = await fs.open('/data/config.json');
-   * 
-   * // Create new file for writing
-   * const fd = await fs.open('/data/new.txt', { create: true });
-   * 
-   * // Create file exclusively (fails if exists)
-   * const fd = await fs.open('/data/unique.txt', { create: true, exclusive: true });
-   * 
-   * // Open and truncate file
-   * const fd = await fs.open('/data/log.txt', { create: true, truncate: true });
-   * ```
-   */
-  async open(t, e) {
-    await this.mount();
-    const { create: r = !1, exclusive: a = !1, truncate: i = !1 } = e || {}, s = p(b(t));
-    try {
-      return r && a ? await u(s, async () => {
-        if (await this.exists(s))
-          throw new H(s);
-        return this._openFile(s, r, i);
-      }) : await this._openFile(s, r, i);
-    } catch (n) {
-      if (n instanceof w)
-        throw n;
-      const o = n && n.name === "TypeMismatchError";
-      throw h(n, {
-        path: s,
-        isDirectory: !!o
-      });
-    }
-  }
-  /**
-   * Internal method to open a file (without locking)
-   *
-   * Multiple FDs for the same path share one sync access handle (OPFS limit),
-   * with independent per-FD positions — similar to Node.js.
-   * @private
-   */
-  async _openFile(t, e, r) {
-    let a = this.openHandles.get(t);
-    if (!a) {
-      const s = await this.getFileHandle(t, e);
-      try {
-        await s.getFile();
-      } catch (o) {
-        throw h(o, { path: t, isDirectory: !0 });
-      }
-      const n = await R(s, t);
-      a = { fileHandle: s, syncHandle: n, refCount: 0 }, this.openHandles.set(t, a);
-    }
-    a.refCount++, r && (a.syncHandle.truncate(0), a.syncHandle.flush());
-    const i = this.nextFd++;
-    return this.openFiles.set(i, {
-      path: t,
-      fileHandle: a.fileHandle,
-      syncHandle: a.syncHandle,
-      position: 0
-    }), i;
-  }
-  /**
-   * Close a file descriptor
-   * 
-   * @param fd - The file descriptor to close
-   * @returns Promise that resolves when the file descriptor is closed
-   * @throws {OPFSError} If the file descriptor is invalid or closing fails
-   * 
-   * @example
-   * ```typescript
-   * const fd = await fs.open('/data/file.txt');
-   * // ... use the file descriptor ...
-   * await fs.close(fd);
-   * ```
-   */
-  async close(t) {
-    const e = this._getFileDescriptor(t);
-    this.openFiles.delete(t);
-    const r = this.openHandles.get(e.path);
-    r && (r.refCount--, r.refCount <= 0 && (A(t, r.syncHandle, e.path), this.openHandles.delete(e.path)));
-  }
-  /**
-   * Read data from a file descriptor
-   * 
-   * @param fd - The file descriptor to read from
-   * @param buffer - The buffer to read data into
-   * @param offset - The offset in the buffer to start writing at
-   * @param length - The number of bytes to read
-   * @param position - The position in the file to read from (null for current position)
-   * @returns Promise that resolves to the number of bytes read and the modified buffer
-   * @throws {OPFSError} If the file descriptor is invalid or reading fails
-   * 
-   * @note This method uses Comlink.transfer() to efficiently pass the buffer as a Transferable Object,
-   *       ensuring zero-copy performance across Web Worker boundaries.
-   * 
-   * @example
-   * ```typescript
-   * const fd = await fs.open('/data/file.txt');
-   * const buffer = new Uint8Array(1024);
-   * const { bytesRead, buffer: modifiedBuffer } = await fs.read(fd, buffer, 0, 1024, null);
-   * console.log(`Read ${bytesRead} bytes`);
-   * // Use modifiedBuffer which contains the actual data
-   * await fs.close(fd);
-   * ```
-   */
-  async read(t, e, r, a, i) {
-    const s = this._getFileDescriptor(t);
-    I(e.length, r, a, i);
-    try {
-      const n = i ?? s.position, o = s.syncHandle.getSize(), { isEOF: c, actualLength: y } = L(n, a, o);
-      if (c)
-        return x({ bytesRead: 0, buffer: e }, [e.buffer]);
-      const f = e.subarray(r, r + y), d = s.syncHandle.read(f, { at: n });
-      return i == null && (s.position = n + d), x({ bytesRead: d, buffer: e }, [e.buffer]);
-    } catch (n) {
-      throw m("read", t, s.path, n);
-    }
-  }
-  /**
-   * Write data to a file descriptor
-   * 
-   * @param fd - The file descriptor to write to
-   * @param buffer - The buffer containing data to write
-   * @param offset - The offset in the buffer to start reading from (default: 0)
-   * @param length - The number of bytes to write (default: entire buffer)
-   * @param position - The position in the file to write to (null/undefined for current position)
-   * @param emitEvent - Whether to emit a change event (default: true)
-   * @returns Promise that resolves to the number of bytes written
-   * @throws {OPFSError} If the file descriptor is invalid or writing fails
-   *
-   * @example
-   * ```typescript
-   * const fd = await fs.open('/data/file.txt', { create: true });
-   * const data = new TextEncoder().encode('Hello, World!');
-   * const bytesWritten = await fs.write(fd, data, 0, data.length, null);
-   * console.log(`Wrote ${bytesWritten} bytes`);
-   * await fs.close(fd);
-   * ```
-   */
-  async write(t, e, r = 0, a, i, s = !0) {
-    const n = this._getFileDescriptor(t), o = a ?? e.length - r;
-    I(e.length, r, o, i);
-    try {
-      const c = i ?? n.position, y = e.subarray(r, r + o), f = n.syncHandle.write(y, { at: c });
-      return (i == null || i === n.position) && (n.position = c + f), s && await this.notifyChange({ path: n.path, type: l.Changed, isDirectory: !1 }), f;
-    } catch (c) {
-      throw m("write", t, n.path, c);
-    }
-  }
-  /**
-   * Get file status information by file descriptor
-   * 
-   * @param fd - The file descriptor
-   * @returns Promise that resolves to FileStat object
-   * @throws {OPFSError} If the file descriptor is invalid
-   * 
-   * @example
-   * ```typescript
-   * const fd = await fs.open('/data/file.txt');
-   * const stats = await fs.fstat(fd);
-   * console.log(`File size: ${stats.size} bytes`);
-   * console.log(`Last modified: ${stats.mtime}`);
-   * 
-   * // If hashing is enabled, hash will be included
-   * if (stats.hash) {
-   *   console.log(`Hash: ${stats.hash}`);
-   * }
-   * ```
-   */
-  async fstat(t) {
-    const e = this._getFileDescriptor(t);
-    return this.stat(e.path);
-  }
-  /**
-   * Truncate file to specified size
-   * 
-   * @param fd - The file descriptor
-   * @param size - The new size of the file (default: 0)
-   * @returns Promise that resolves when truncation is complete
-   * @throws {OPFSError} If the file descriptor is invalid or truncation fails
-   * 
-   * @example
-   * ```typescript
-   * const fd = await fs.open('/data/file.txt', { create: true });
-   * await fs.truncate(fd, 100); // Truncate to 100 bytes
-   * ```
-   */
-  async ftruncate(t, e = 0) {
-    const r = this._getFileDescriptor(t);
-    if (e < 0 || !Number.isInteger(e))
-      throw new C("argument", "Invalid size");
-    try {
-      r.syncHandle.truncate(e), r.syncHandle.flush(), r.position > e && (r.position = e), await this.notifyChange({ path: r.path, type: l.Changed, isDirectory: !1 });
-    } catch (a) {
-      throw m("truncate", t, r.path, a);
-    }
-  }
-  /**
-   * Synchronize file data to storage (fsync equivalent)
-   * 
-   * @param fd - The file descriptor
-   * @returns Promise that resolves when synchronization is complete
-   * @throws {OPFSError} If the file descriptor is invalid or sync fails
-   * 
-   * @example
-   * ```typescript
-   * const fd = await fs.open('/data/file.txt', { create: true });
-   * await fs.write(fd, data);
-   * await fs.fsync(fd); // Ensure data is written to storage
-   * ```
-   */
-  async fsync(t) {
-    const e = this._getFileDescriptor(t);
-    try {
-      e.syncHandle.flush();
-    } catch (r) {
-      throw m("sync", t, e.path, r);
-    }
-  }
-  /**
-   * Dispose of resources and clean up the file system instance
-   * 
-   * This method should be called when the file system instance is no longer needed
-   * to properly clean up resources like the broadcast channel and watch timers.
-   */
-  dispose() {
-    this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchers.clear();
-    for (const [t, e] of this.openHandles)
-      A(-1, e.syncHandle, t);
-    this.openHandles.clear(), this.openFiles.clear(), this.nextFd = 1;
-  }
-  /**
-   * Synchronize the file system with external data
-   * 
-   * Syncs the file system with an array of entries containing paths and data.
-   * This is useful for importing data from external sources or syncing with remote data.
-   * 
-   * @param entries - Array of [path, data] tuples to sync
-   * @returns Promise that resolves when synchronization is complete
-   * @throws {OPFSError} If the synchronization fails
-   * 
-   * @example
-   * ```typescript
-   * // Sync with external data
-   * const entries: [string, string | Uint8Array | Blob][] = [
-   *   ['/config.json', JSON.stringify({ theme: 'dark' })],
-   *   ['/data/binary.dat', new Uint8Array([1, 2, 3, 4])],
-   *   ['/upload.txt', new Blob(['file content'], { type: 'text/plain' })]
-   * ];
-   * 
-   * // Sync without clearing existing files
-   * await fs.sync(entries);
-   * 
-   * // Clean file system and then sync
-   * await fs.sync(entries, { cleanBefore: true });
-   * ```
-   */
-  async createIndex(t) {
-    await this.mount();
-    try {
-      for (const [e, r] of t) {
-        const a = p(e);
-        let i;
-        r instanceof Blob ? i = await U(r) : typeof r == "string" ? i = new TextEncoder().encode(r) : i = r, await this.writeFile(a, i);
-      }
-    } catch (e) {
-      throw e instanceof w ? e : h(e);
-    }
-  }
-}
+import { A as e, K as s, B as o, D as t, E as i, F as n, g as E, c, I as l, f as S, O as d, a as p, d as m, e as h, P as F, b as O, S as y, V as P, W as f, k as u, x, v as B, H as A, i as v, y as I, u as N, h as b, J as g, N as z, l as D, M as H, t as L, L as T, q as k, j as M, m as R, p as W, o as j, n as q, z as w, r as C, G as V, s as _, C as G, w as J } from "./BaseOPFS-BusBkyJX.js";
+import { O as U } from "./OPFSSync-D7obTsl3.js";
+import { O as Y } from "./OPFSAsync-CO44W23e.js";
 export {
-  H as AlreadyExistsError,
-  K as BINARY_FILE_EXTENSIONS,
-  T as DirectoryOperationError,
-  S as ExistenceError,
-  X as FileBusyError,
-  F as FileSystemOperationError,
-  B as FileTypeError,
-  Y as IOError,
-  P as InitializationFailedError,
-  w as OPFSError,
-  Q as OPFSNotSupportedError,
-  V as OPFSWorker,
-  Z as OperationAbortedError,
-  N as OperationNotSupportedError,
-  z as PathError,
-  tt as PermissionError,
-  et as StorageError,
-  C as ValidationError,
-  l as WatchEventType,
-  v as basename,
-  at as buffersEqual,
-  M as calculateFileHash,
-  L as calculateReadLength,
-  O as checkOPFSSupport,
-  U as convertBlobToUint8Array,
-  rt as createBuffer,
-  m as createFDError,
-  R as createSyncHandleSafe,
-  it as decodeBuffer,
-  E as dirname,
-  st as encodeString,
-  nt as extname,
-  ot as isBinaryFileExtension,
-  ct as isPathExcluded,
-  k as joinPath,
-  h as mapDomError,
-  g as matchMinimatch,
-  _ as normalizeMinimatch,
-  p as normalizePath,
-  $ as removeEntry,
-  b as resolvePath,
-  A as safeCloseSyncHandle,
-  D as splitPath,
-  I as validateReadWriteArgs,
-  u as withLock
+  e as AlreadyExistsError,
+  s as BINARY_FILE_EXTENSIONS,
+  o as BaseOPFS,
+  t as DirectoryOperationError,
+  i as ExistenceError,
+  n as FileBusyError,
+  E as FileSystemOperationError,
+  c as FileTypeError,
+  l as IOError,
+  S as InitializationFailedError,
+  Y as OPFSAsync,
+  d as OPFSError,
+  p as OPFSNotSupportedError,
+  U as OPFSSync,
+  m as OperationAbortedError,
+  h as OperationNotSupportedError,
+  F as PathError,
+  O as PermissionError,
+  y as StorageError,
+  P as ValidationError,
+  f as WatchEventType,
+  u as basename,
+  x as buffersEqual,
+  B as calculateFileHash,
+  A as calculateReadLength,
+  v as checkOPFSSupport,
+  I as convertBlobToUint8Array,
+  N as createBuffer,
+  b as createFDError,
+  g as createSyncHandleSafe,
+  z as decodeBuffer,
+  D as dirname,
+  H as encodeString,
+  L as extname,
+  T as isBinaryFileExtension,
+  k as isPathExcluded,
+  M as joinPath,
+  R as mapDomError,
+  W as matchMinimatch,
+  j as normalizeMinimatch,
+  q as normalizePath,
+  w as removeEntry,
+  C as resolvePath,
+  V as safeCloseSyncHandle,
+  _ as splitPath,
+  G as validateReadWriteArgs,
+  J as withLock
 };
 //# sourceMappingURL=index.pure.js.map