opfs-worker 0.2.0 → 0.2.2

package/dist/raw.js

@@ -1,151 +1,6 @@
-import { expose as E } from "comlink";
-class o extends Error {
-  constructor(e, t, r) {
-    super(e), this.code = t, this.path = r, this.name = "OPFSError";
-  }
-}
-class S extends o {
-  constructor() {
-    super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
-  }
-}
-class y extends o {
-  constructor() {
-    super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
-  }
-}
-class g extends o {
-  constructor(e, t) {
-    super(e, "INVALID_PATH", t);
-  }
-}
-class m extends o {
-  constructor(e) {
-    super(`File not found: ${e}`, "FILE_NOT_FOUND", e);
-  }
-}
-function A(a, e = "utf-8") {
-  switch (e) {
-    case "utf8":
-    case "utf-8":
-      return new TextEncoder().encode(a);
-    case "utf16le":
-    case "ucs2":
-    case "ucs-2":
-      return I(a);
-    case "ascii":
-      return $(a);
-    case "latin1":
-      return v(a);
-    case "binary":
-      return Uint8Array.from(a, (t) => t.charCodeAt(0));
-    case "base64":
-      return Uint8Array.from(atob(a), (t) => t.charCodeAt(0));
-    case "hex":
-      if (!/^[\da-f]+$/i.test(a) || a.length % 2 !== 0)
-        throw new o("Invalid hex string", "INVALID_HEX_FORMAT");
-      return Uint8Array.from(a.match(/.{1,2}/g).map((t) => parseInt(t, 16)));
-    default:
-      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(a);
-  }
-}
-function D(a, e = "utf-8") {
-  switch (e) {
-    case "utf8":
-    case "utf-8":
-      return new TextDecoder().decode(a);
-    case "utf16le":
-    case "ucs2":
-    case "ucs-2":
-      return T(a);
-    case "latin1":
-      return String.fromCharCode(...a);
-    case "binary":
-      return String.fromCharCode(...a);
-    case "ascii":
-      return String.fromCharCode(...a.map((t) => t & 127));
-    case "base64":
-      return btoa(String.fromCharCode(...a));
-    case "hex":
-      return Array.from(a).map((t) => t.toString(16).padStart(2, "0")).join("");
-    default:
-      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(a);
-  }
-}
-function I(a) {
-  const e = new Uint8Array(a.length * 2);
-  for (let t = 0; t < a.length; t++) {
-    const r = a.charCodeAt(t);
-    e[t * 2] = r & 255, e[t * 2 + 1] = r >> 8;
-  }
-  return e;
-}
-function T(a) {
-  a.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), a = a.slice(0, a.length - 1));
-  const e = new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2);
-  return String.fromCharCode(...e);
-}
-function v(a) {
-  const e = new Uint8Array(a.length);
-  for (let t = 0; t < a.length; t++)
-    e[t] = a.charCodeAt(t) & 255;
-  return e;
-}
-function $(a) {
-  const e = new Uint8Array(a.length);
-  for (let t = 0; t < a.length; t++)
-    e[t] = a.charCodeAt(t) & 127;
-  return e;
-}
-function N() {
-  if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
-    throw new S();
-}
-function f(a) {
-  return Array.isArray(a) ? a : a.split("/").filter(Boolean);
-}
-function p(a) {
-  return typeof a == "string" ? a ?? "/" : `/${a.join("/")}`;
-}
-function H(a, e = "utf-8") {
-  return typeof a == "string" ? A(a, e) : a instanceof Uint8Array ? a : new Uint8Array(a);
-}
-async function x(a) {
-  const e = await a.createSyncAccessHandle();
-  try {
-    const t = e.getSize(), r = new Uint8Array(t);
-    return e.read(r, { at: 0 }), r;
-  } finally {
-    e.close();
-  }
-}
-async function F(a, e, t, r = {}) {
-  let n = null;
-  try {
-    n = await a.createSyncAccessHandle();
-    const i = H(e, t), s = r.append ? n.getSize() : 0;
-    n.write(i, { at: s }), r.truncate && !r.append && n.truncate(i.byteLength), n.flush();
-  } catch (i) {
-    console.error(i);
-    const s = r.append ? "append" : "write";
-    throw new o(`Failed to ${s} file`, `${s.toUpperCase()}_FAILED`);
-  } finally {
-    if (n)
-      try {
-        n.close();
-      } catch {
-      }
-  }
-}
-async function O(a, e = "SHA-1") {
-  try {
-    const t = new Uint8Array(a), r = await crypto.subtle.digest(e, t);
-    return Array.from(new Uint8Array(r)).map((i) => i.toString(16).padStart(2, "0")).join("");
-  } catch (t) {
-    throw console.warn(`Failed to calculate ${e} hash:`, t), t;
-  }
-}
-class U {
+import { expose as p } from "comlink";
+import { d as v, O as o, b as f, s as u, P as E, i as I, o as S, F as d, w as g, j as T, e as m, f as y, k as M, r as H, n as F, l as P } from "./helpers-Co-qCBmA.js";
+class $ {
   /** Root directory handle for the file system */
   root = null;
   /** Watch event callback */
@@ -158,19 +13,23 @@ class U {
   watchInterval = 1e3;
   /** Flag to avoid concurrent scans */
   scanning = !1;
+  /** Promise to prevent concurrent mount operations */
+  mountingPromise = null;
   /**
    * Creates a new OPFSFileSystem instance
    * 
+   * @param watchCallback - Optional callback for file change events
+   * @param watchOptions - Optional configuration for watching
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
-  constructor() {
-    N();
+  constructor(t, e) {
+    v(), t && (this.watchCallback = t, e?.watchInterval && (this.watchInterval = e.watchInterval)), this.mount("/");
   }
   /**
    * Initialize the file system within a given directory
    * 
    * This method sets up the root directory for all subsequent operations.
-   * It must be called before any other file system operations.
+   * If no root is specified, it will use the OPFS root directory.
    * 
    * @param root - The root path for the file system (default: '/')
    * @returns Promise that resolves to true if initialization was successful
@@ -179,15 +38,52 @@ class U {
    * @example
    * ```typescript
    * const fs = new OPFSFileSystem();
-   * const success = await fs.init('/my-app');
+   * 
+   * // Use OPFS root (default)
+   * await fs.mount();
+   * 
+   * // Use custom directory
+   * await fs.mount('/my-app');
    * ```
    */
-  async mount(e = "/", t, r) {
-    try {
-      const n = await navigator.storage.getDirectory();
-      return this.root = await this.getDirectoryHandle(e, !0, n), t && (this.watchCallback = t, r?.watchInterval && (this.watchInterval = r.watchInterval)), !0;
-    } catch (n) {
-      throw console.error(n), new o("Failed to initialize OPFS", "INIT_FAILED");
+  async mount(t = "/") {
+    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (e, i) => {
+      this.root = null;
+      try {
+        const r = await navigator.storage.getDirectory();
+        t === "/" ? this.root = r : this.root = await this.getDirectoryHandle(t, !0, r), e(!0);
+      } catch (r) {
+        console.error(r), i(new o("Failed to initialize OPFS", "INIT_FAILED"));
+      } finally {
+        this.mountingPromise = null;
+      }
+    }), this.mountingPromise;
+  }
+  /**
+   * Set the watch callback for file change events
+   * 
+   * @param callback - The callback function to invoke when files change
+   * @param options - Optional configuration for watching
+   */
+  setWatchCallback(t, e) {
+    this.watchCallback = t, e?.watchInterval && (this.watchInterval = e.watchInterval);
+  }
+  /**
+   * Automatically mount the OPFS root if not already mounted
+   * 
+   * This method is called internally when file operations are performed
+   * without explicitly mounting first.
+   * 
+   * @returns Promise that resolves when auto-mount is complete
+   * @throws {OPFSError} If auto-mount fails
+   */
+  async ensureMounted() {
+    if (!this.root) {
+      if (this.mountingPromise) {
+        await this.mountingPromise;
+        return;
+      }
+      throw new o("OPFS not mounted", "NOT_MOUNTED");
     }
   }
   /**
@@ -208,14 +104,14 @@ class U {
    * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
    * ```
    */
-  async getDirectoryHandle(e, t = !1, r = this.root) {
-    if (!r)
-      throw new y();
-    const n = Array.isArray(e) ? e : f(e);
-    let i = r;
-    for (const s of n)
-      i = await i.getDirectoryHandle(s, { create: t });
-    return i;
+  async getDirectoryHandle(t, e = !1, i = this.root) {
+    if (!i)
+      throw new f();
+    const r = Array.isArray(t) ? t : u(t);
+    let a = i;
+    for (const n of r)
+      a = await a.getDirectoryHandle(n, { create: e });
+    return a;
   }
   /**
    * Get a file handle from a path
@@ -236,14 +132,14 @@ class U {
    * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
    * ```
    */
-  async getFileHandle(e, t = !1, r = this.root) {
-    if (!r)
-      throw new y();
-    const n = f(e);
-    if (n.length === 0)
-      throw new g("Path must not be empty", Array.isArray(e) ? e.join("/") : e);
-    const i = n.pop();
-    return (await this.getDirectoryHandle(n, t, r)).getFileHandle(i, { create: t });
+  async getFileHandle(t, e = !1, i = this.root) {
+    if (!i)
+      throw new f();
+    const r = u(t);
+    if (r.length === 0)
+      throw new E("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+    const a = r.pop();
+    return (await this.getDirectoryHandle(r, e, i)).getFileHandle(a, { create: e });
   }
   /**
    * Recursively list all files and directories with their stats
@@ -282,34 +178,35 @@ class U {
    * }
    * ```
    */
-  async index(e) {
-    const t = /* @__PURE__ */ new Map(), r = async (n) => {
-      const i = await this.readdir(n, { withFileTypes: !0 });
-      for (const s of i) {
-        const c = `${n === "/" ? "" : n}/${s.name}`;
+  async index(t) {
+    const e = /* @__PURE__ */ new Map(), i = async (r) => {
+      const a = await this.readdir(r, { withFileTypes: !0 });
+      for (const n of a) {
+        const s = `${r === "/" ? "" : r}/${n.name}`;
         try {
-          const l = await this.stat(c, e);
-          t.set(c, l), l.isDirectory && await r(c);
-        } catch (l) {
-          console.warn(`Skipping broken entry: ${c}`, l);
+          const c = await this.stat(s, t);
+          e.set(s, c), c.isDirectory && await i(s);
+        } catch (c) {
+          console.warn(`Skipping broken entry: ${s}`, c);
         }
       }
     };
-    return t.set("/", {
+    return e.set("/", {
       kind: "directory",
       size: 0,
       mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
       ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
       isFile: !1,
       isDirectory: !0
-    }), await r("/"), t;
+    }), await i("/"), e;
   }
-  async readFile(e, t = "utf-8") {
+  async readFile(t, e = "utf-8") {
+    await this.ensureMounted();
     try {
-      const r = await this.getFileHandle(e, !1), n = await x(r);
-      return t === "binary" ? n : D(n, t);
-    } catch (r) {
-      throw console.error(r), new m(e);
+      const i = await this.getFileHandle(t, !1), r = await I(i);
+      return e === "binary" ? r : S(r, e);
+    } catch (i) {
+      throw console.error(i), new d(t);
     }
   }
   /**
@@ -337,9 +234,10 @@ class U {
    * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');
    * ```
    */
-  async writeFile(e, t, r) {
-    const n = await this.getFileHandle(e, !0);
-    await F(n, t, r, { truncate: !0 });
+  async writeFile(t, e, i) {
+    await this.ensureMounted();
+    const r = await this.getFileHandle(t, !0);
+    await g(r, e, i, { truncate: !0 });
   }
   /**
    * Append data to a file
@@ -363,9 +261,10 @@ class U {
    * await fs.appendFile('/data/binary.dat', additionalData);
    * ```
    */
-  async appendFile(e, t, r) {
-    const n = await this.getFileHandle(e, !0);
-    await F(n, t, r, { append: !0 });
+  async appendFile(t, e, i) {
+    await this.ensureMounted();
+    const r = await this.getFileHandle(t, !0);
+    await g(r, e, i, { append: !0 });
   }
   /**
    * Create a directory
@@ -388,20 +287,20 @@ class U {
    * await fs.mkdir('/users/john/documents/projects', { recursive: true });
    * ```
    */
-  async mkdir(e, t) {
-    if (!this.root)
-      throw new y();
-    const r = t?.recursive ?? !1, n = f(e);
-    let i = this.root;
-    for (let s = 0; s < n.length; s++) {
-      const c = n[s];
+  async mkdir(t, e) {
+    if (await this.ensureMounted(), !this.root)
+      throw new f();
+    const i = e?.recursive ?? !1, r = u(t);
+    let a = this.root;
+    for (let n = 0; n < r.length; n++) {
+      const s = r[n];
       try {
-        i = await i.getDirectoryHandle(c, { create: r || s === n.length - 1 });
-      } catch (l) {
-        throw l.name === "NotFoundError" ? new o(
-          `Parent directory does not exist: ${p(n.slice(0, s + 1))}`,
+        a = await a.getDirectoryHandle(s, { create: i || n === r.length - 1 });
+      } catch (c) {
+        throw c.name === "NotFoundError" ? new o(
+          `Parent directory does not exist: ${T(r.slice(0, n + 1))}`,
           "ENOENT"
-        ) : l.name === "TypeMismatchError" ? new o(`Path segment is not a directory: ${c}`, "ENOTDIR") : new o("Failed to create directory", "MKDIR_FAILED");
+        ) : c.name === "TypeMismatchError" ? new o(`Path segment is not a directory: ${s}`, "ENOTDIR") : new o("Failed to create directory", "MKDIR_FAILED");
       }
     }
   }
@@ -434,62 +333,63 @@ class U {
    * console.log(`Hash: ${statsWithHash.hash}`);
    * ```
    */
-  async stat(e, t) {
-    const r = f(e), n = r.pop(), i = await this.getDirectoryHandle(r, !1), s = t?.includeHash ?? !1, c = t?.hashAlgorithm ?? "SHA-1";
+  async stat(t, e) {
+    await this.ensureMounted();
+    const i = m(t), r = await this.getDirectoryHandle(y(t), !1), a = e?.includeHash ?? !1, n = e?.hashAlgorithm ?? "SHA-1";
     try {
-      const h = await (await i.getFileHandle(n, { create: !1 })).getFile(), w = {
+      const c = await (await r.getFileHandle(i, { create: !1 })).getFile(), l = {
         kind: "file",
-        size: h.size,
-        mtime: new Date(h.lastModified).toISOString(),
-        ctime: new Date(h.lastModified).toISOString(),
+        size: c.size,
+        mtime: new Date(c.lastModified).toISOString(),
+        ctime: new Date(c.lastModified).toISOString(),
         isFile: !0,
         isDirectory: !1
       };
-      if (s)
+      if (a)
         try {
-          const u = new Uint8Array(await h.arrayBuffer()), d = await O(u, c);
-          w.hash = d;
-        } catch (u) {
-          console.warn(`Failed to calculate hash for ${e}:`, u);
+          const h = new Uint8Array(await c.arrayBuffer()), w = await M(h, n);
+          l.hash = w;
+        } catch (h) {
+          console.warn(`Failed to calculate hash for ${t}:`, h);
         }
-      return w;
-    } catch (l) {
-      if (l.name !== "TypeMismatchError" && l.name !== "NotFoundError")
+      return l;
+    } catch (s) {
+      if (s.name !== "TypeMismatchError" && s.name !== "NotFoundError")
         throw new o("Failed to stat (file)", "STAT_FAILED");
     }
     try {
-      return await i.getDirectoryHandle(n, { create: !1 }), {
+      return await r.getDirectoryHandle(i, { create: !1 }), {
         kind: "directory",
         size: 0,
         mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
         ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
         isFile: !1,
         isDirectory: !0
-        // Directories don't have hashes
       };
-    } catch (l) {
-      throw l.name === "NotFoundError" ? new o(`No such file or directory: ${e}`, "ENOENT") : new o("Failed to stat (directory)", "STAT_FAILED");
+    } catch (s) {
+      throw s.name === "NotFoundError" ? new o(`No such file or directory: ${t}`, "ENOENT") : new o("Failed to stat (directory)", "STAT_FAILED");
     }
   }
-  async readdir(e, t) {
-    const r = t?.withFileTypes ?? !1, n = await this.getDirectoryHandle(e, !1);
-    if (r) {
-      const i = [];
-      for await (const [s, c] of n.entries()) {
-        const l = c.kind === "file";
-        i.push({
-          name: s,
-          kind: c.kind,
-          isFile: l,
-          isDirectory: !l
+  async readdir(t, e) {
+    await this.ensureMounted();
+    const i = e?.withFileTypes ?? !1, r = await this.getDirectoryHandle(t, !1);
+    if (i) {
+      const a = [];
+      for await (const [n, s] of r.entries()) {
+        const c = s.kind === "file";
+        a.push({
+          name: n,
+          kind: s.kind,
+          isFile: c,
+          isDirectory: !c
         });
       }
-      return i;
+      return a;
     } else {
-      const i = [];
-      for await (const [s] of n.entries())
-        i.push(s);
-      return i;
+      const a = [];
+      for await (const [n] of r.entries())
+        a.push(n);
+      return a;
     }
   }
   /**
@@ -506,27 +406,28 @@ class U {
    * console.log(`File exists: ${exists}`);
    * ```
    */
-  async exists(e) {
-    const t = f(e), r = t.pop();
-    let n = null;
+  async exists(t) {
+    await this.ensureMounted();
+    const e = m(t);
+    let i = null;
     try {
-      n = await this.getDirectoryHandle(t, !1);
-    } catch (i) {
-      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
+      i = await this.getDirectoryHandle(y(t), !1);
+    } catch (r) {
+      throw (r.name === "NotFoundError" || r.name === "TypeMismatchError") && (i = null), r;
     }
-    if (!n || !r)
+    if (!i || !e)
       return !1;
     try {
-      return await n.getFileHandle(r, { create: !1 }), !0;
-    } catch (i) {
-      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
-        throw i;
+      return await i.getFileHandle(e, { create: !1 }), !0;
+    } catch (r) {
+      if (r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+        throw r;
     }
     try {
-      return await n.getDirectoryHandle(r, { create: !1 }), !0;
-    } catch (i) {
-      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
-        throw i;
+      return await i.getDirectoryHandle(e, { create: !1 }), !0;
+    } catch (r) {
+      if (r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+        throw r;
     }
     return !1;
   }
@@ -549,15 +450,16 @@ class U {
    * await fs.clear('/data');
    * ```
    */
-  async clear(e = "/") {
+  async clear(t = "/") {
+    await this.ensureMounted();
     try {
-      const t = await this.readdir(e, { withFileTypes: !0 });
-      for (const r of t) {
-        const n = `${e === "/" ? "" : e}/${r.name}`;
-        await this.remove(n, { recursive: !0 });
+      const e = await this.readdir(t, { withFileTypes: !0 });
+      for (const i of e) {
+        const r = `${t === "/" ? "" : t}/${i.name}`;
+        await this.remove(r, { recursive: !0 });
       }
-    } catch (t) {
-      throw t instanceof o ? t : new o(`Failed to clear directory: ${e}`, "CLEAR_FAILED");
+    } catch (e) {
+      throw e instanceof o ? e : new o(`Failed to clear directory: ${t}`, "CLEAR_FAILED");
     }
   }
   /**
@@ -584,18 +486,19 @@ class U {
    * await fs.rm('/maybe/exists', { force: true });
    * ```
    */
-  async remove(e, t) {
-    const r = t?.recursive ?? !1, n = t?.force ?? !1, i = f(e), s = i.pop();
-    if (!s)
-      throw new g("Invalid path", e);
-    const c = await this.getDirectoryHandle(i, !1);
+  async remove(t, e) {
+    await this.ensureMounted();
+    const i = e?.recursive ?? !1, r = e?.force ?? !1, a = m(t);
+    if (!a)
+      throw new E("Invalid path", t);
+    const n = await this.getDirectoryHandle(y(t), !1);
     try {
-      await c.removeEntry(s, { recursive: r });
-    } catch (l) {
-      if (l.name === "NotFoundError") {
-        if (!n)
-          throw new o(`No such file or directory: ${e}`, "ENOENT");
-      } else throw l.name === "InvalidModificationError" ? new o(`Directory not empty: ${e}. Use recursive option to force removal.`, "ENOTEMPTY") : l.name === "TypeMismatchError" && !r ? new o(`Cannot remove directory without recursive option: ${e}`, "EISDIR") : new o(`Failed to remove path: ${e}`, "RM_FAILED");
+      await n.removeEntry(a, { recursive: i });
+    } catch (s) {
+      if (s.name === "NotFoundError") {
+        if (!r)
+          throw new o(`No such file or directory: ${t}`, "ENOENT");
+      } else throw s.name === "InvalidModificationError" ? new o(`Directory not empty: ${t}. Use recursive option to force removal.`, "ENOTEMPTY") : s.name === "TypeMismatchError" && !i ? new o(`Cannot remove directory without recursive option: ${t}`, "EISDIR") : new o(`Failed to remove path: ${t}`, "RM_FAILED");
     }
   }
   /**
@@ -616,23 +519,15 @@ class U {
    * console.log(absolute); // '/data/file.txt'
    * ```
    */
-  async realpath(e) {
+  async realpath(t) {
+    await this.ensureMounted();
     try {
-      const t = f(e), r = [];
-      for (const s of t)
-        if (!(s === "." || s === ""))
-          if (s === "..") {
-            if (r.length === 0)
-              throw new o("Path escapes root", "EINVAL");
-            r.length > 0 && r.pop();
-          } else
-            r.push(s);
-      const n = p(r);
-      if (!await this.exists(n))
-        throw new m(n);
-      return n;
-    } catch (t) {
-      throw t instanceof o ? t : new o(`Failed to resolve path: ${e}`, "REALPATH_FAILED");
+      const e = H(t);
+      if (!await this.exists(e))
+        throw new d(e);
+      return e;
+    } catch (e) {
+      throw e instanceof o ? e : new o(`Failed to resolve path: ${t}`, "REALPATH_FAILED");
     }
   }
   /**
@@ -651,13 +546,14 @@ class U {
    * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
    * ```
    */
-  async rename(e, t) {
+  async rename(t, e) {
+    await this.ensureMounted();
     try {
-      if (!await this.exists(e))
-        throw new m(e);
-      await this.copy(e, t, { recursive: !0 }), await this.remove(e, { recursive: !0 });
-    } catch (r) {
-      throw r instanceof o ? r : new o(`Failed to rename from ${e} to ${t}`, "RENAME_FAILED");
+      if (!await this.exists(t))
+        throw new d(t);
+      await this.copy(t, e, { recursive: !0 }), await this.remove(t, { recursive: !0 });
+    } catch (i) {
+      throw i instanceof o ? i : new o(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED");
     }
   }
   /**
@@ -676,91 +572,93 @@ class U {
    * @example
    * ```typescript
    * // Copy a file
-   * await fs.cp('/source/file.txt', '/dest/file.txt');
+   * await fs.copy('/source/file.txt', '/dest/file.txt');
    * 
    * // Copy a directory and all its contents
-   * await fs.cp('/source/dir', '/dest/dir', { recursive: true });
+   * await fs.copy('/source/dir', '/dest/dir', { recursive: true });
    * 
    * // Copy without overwriting existing files
-   * await fs.cp('/source', '/dest', { recursive: true, force: false });
+   * await fs.copy('/source', '/dest', { recursive: true, force: false });
    * ```
    */
-  async copy(e, t, r) {
+  async copy(t, e, i) {
+    await this.ensureMounted();
     try {
-      const n = r?.recursive ?? !1, i = r?.force ?? !0;
-      if (!await this.exists(e))
-        throw new o(`Source does not exist: ${e}`, "ENOENT");
-      if (await this.exists(t) && !i)
-        throw new o(`Destination already exists: ${t}`, "EEXIST");
-      if ((await this.stat(e)).isFile) {
-        const h = await this.readFile(e, "binary");
-        await this.writeFile(t, h);
+      const r = i?.recursive ?? !1, a = i?.force ?? !0;
+      if (!await this.exists(t))
+        throw new o(`Source does not exist: ${t}`, "ENOENT");
+      if (await this.exists(e) && !a)
+        throw new o(`Destination already exists: ${e}`, "EEXIST");
+      if ((await this.stat(t)).isFile) {
+        const l = await this.readFile(t, "binary");
+        await this.writeFile(e, l);
       } else {
-        if (!n)
-          throw new o(`Cannot copy directory without recursive option: ${e}`, "EISDIR");
-        await this.mkdir(t, { recursive: !0 });
-        const h = await this.readdir(e, { withFileTypes: !0 });
-        for (const w of h) {
-          const u = `${e}/${w.name}`, d = `${t}/${w.name}`;
-          await this.copy(u, d, { recursive: !0, force: i });
+        if (!r)
+          throw new o(`Cannot copy directory without recursive option: ${t}`, "EISDIR");
+        await this.mkdir(e, { recursive: !0 });
+        const l = await this.readdir(t, { withFileTypes: !0 });
+        for (const h of l) {
+          const w = `${t}/${h.name}`, D = `${e}/${h.name}`;
+          await this.copy(w, D, { recursive: !0, force: a });
         }
       }
-    } catch (n) {
-      throw n instanceof o ? n : new o(`Failed to copy from ${e} to ${t}`, "CP_FAILED");
+    } catch (r) {
+      throw r instanceof o ? r : new o(`Failed to copy from ${t} to ${e}`, "CP_FAILED");
     }
   }
   /**
    * Start watching a file or directory for changes
    */
-  async watch(e) {
-    const t = e.startsWith("/") ? e : `/${e}`, r = await this.buildSnapshot(t);
-    this.watchers.set(t, r), this.watchTimer || (this.watchTimer = setInterval(() => {
+  async watch(t) {
+    await this.ensureMounted();
+    const e = F(t), i = await this.buildSnapshot(e);
+    this.watchers.set(e, i), this.watchTimer || (this.watchTimer = setInterval(() => {
       this.scanWatches();
     }, this.watchInterval));
   }
   /**
    * Stop watching a previously watched path
    */
-  unwatch(e) {
-    const t = e.startsWith("/") ? e : `/${e}`;
-    this.watchers.delete(t), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
-  }
-  async buildSnapshot(e) {
-    const t = /* @__PURE__ */ new Map(), r = async (n) => {
-      const i = await this.stat(n);
-      if (t.set(n, i), i.isDirectory) {
-        const s = await this.readdir(n, { withFileTypes: !0 });
-        for (const c of s) {
-          const l = `${n === "/" ? "" : n}/${c.name}`;
-          await r(l);
+  unwatch(t) {
+    const e = F(t);
+    this.watchers.delete(e), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
+  }
+  async buildSnapshot(t) {
+    const e = /* @__PURE__ */ new Map(), i = async (r) => {
+      const a = await this.stat(r);
+      if (e.set(r, a), a.isDirectory) {
+        const n = await this.readdir(r, { withFileTypes: !0 });
+        for (const s of n) {
+          const c = `${r === "/" ? "" : r}/${s.name}`;
+          await i(c);
         }
       }
     };
-    return await r(e), t;
+    return await i(t), e;
   }
   async scanWatches() {
     if (!this.scanning) {
       this.scanning = !0;
       try {
         await Promise.all(
-          [...this.watchers.entries()].map(async ([e, t]) => {
-            let r;
+          [...this.watchers.entries()].map(async ([t, e]) => {
+            let i;
             try {
-              r = await this.buildSnapshot(e);
+              i = await this.buildSnapshot(t);
             } catch {
-              r = /* @__PURE__ */ new Map();
+              i = /* @__PURE__ */ new Map();
             }
-            const n = [];
-            for (const [i, s] of r) {
-              const c = t.get(i);
-              c ? (c.mtime !== s.mtime || c.size !== s.size) && n.push({ path: i, type: "change" }) : n.push({ path: i, type: "create" });
+            const r = [];
+            for (const [a, n] of i) {
+              const s = e.get(a);
+              s ? (s.mtime !== n.mtime || s.size !== n.size) && r.push({ path: a, type: "change" }) : r.push({ path: a, type: "create" });
             }
-            for (const i of t.keys())
-              r.has(i) || n.push({ path: i, type: "delete" });
-            if (n.length && this.watchCallback)
-              for (const i of n)
-                this.watchCallback(i);
-            this.watchers.set(e, r);
+            for (const a of e.keys())
+              i.has(a) || r.push({ path: a, type: "delete" });
+            if (r.length && this.watchCallback)
+              for (const a of r)
+                this.watchCallback(a);
+            this.watchers.set(t, i);
           })
         );
       } finally {
@@ -796,26 +694,22 @@ class U {
    * await fs.sync(entries, { cleanBefore: true });
    * ```
    */
-  async sync(e, t) {
+  async sync(t, e) {
+    await this.ensureMounted();
     try {
-      (t?.cleanBefore ?? !1) && await this.clear("/");
-      for (const [n, i] of e) {
-        const s = n.startsWith("/") ? n : `/${n}`;
-        let c;
-        if (i instanceof Blob) {
-          const l = await i.arrayBuffer();
-          c = new Uint8Array(l);
-        } else
-          c = i;
-        await this.writeFile(s, c);
+      (e?.cleanBefore ?? !1) && await this.clear("/");
+      for (const [r, a] of t) {
+        const n = F(r);
+        let s;
+        a instanceof Blob ? s = await P(a) : s = a, await this.writeFile(n, s);
       }
-    } catch (r) {
-      throw r instanceof o ? r : new o("Failed to sync file system", "SYNC_FAILED");
+    } catch (i) {
+      throw i instanceof o ? i : new o("Failed to sync file system", "SYNC_FAILED");
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && E(new U());
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && p(new $());
 export {
-  U as OPFSWorker
+  $ as OPFSWorker
 };
 //# sourceMappingURL=raw.js.map