buritifs 0.0.1

package/dist/chunk-QOM3Q3WE.js

@@ -0,0 +1,803 @@
+// src/core/Explorer/file.ts
+var ExplorerFile = class _ExplorerFile {
+  constructor(base, storage) {
+    this.ok = true;
+    this.error = null;
+    this.type = "file";
+    this.base = base;
+    this.storage = storage;
+  }
+  get path() {
+    return this.base;
+  }
+  // ─── Info ─────────────────────────────────────────────────
+  async info() {
+    return await this.storage.info({ path: this.base });
+  }
+  // ─── Refactor ─────────────────────────────────────────────
+  async rename({ name }) {
+    const result = await this.storage.rename({ path: this.base, name });
+    if (!result.ok) return result;
+    const parentPath = this.base.substring(0, this.base.lastIndexOf("/")) || "/";
+    this.base = `${parentPath === "/" ? "" : parentPath}/${name}`;
+    return { ok: true, error: null };
+  }
+  async copy({ to, priority }) {
+    const result = await this.storage.copy({ fromPath: this.base, toPath: to, merge: false, priority });
+    if (!result.ok) return result;
+    return await this.storage.source({ path: to });
+  }
+  async move({ to, force }) {
+    const result = await this.storage.move({ fromPath: this.base, toPath: to, force });
+    if (!result.ok) return result;
+    const newInstance = await this.storage.source({ path: to });
+    if (newInstance instanceof _ExplorerFile) this.base = newInstance.base;
+    return { ok: true, error: null };
+  }
+  async delete() {
+    return await this.storage.delete({ path: this.base });
+  }
+  async exists() {
+    return await this.storage.exists({ path: this.base });
+  }
+  async write({ content }) {
+    return await this.storage.write({ path: this.base, content });
+  }
+  async read() {
+    return await this.storage.read({ path: this.base });
+  }
+};
+
+// src/core/Explorer/folder.ts
+var ExplorerFolder = class _ExplorerFolder {
+  constructor(base, storage) {
+    this.ok = true;
+    this.error = null;
+    this.type = "folder";
+    this.base = base == "/" ? base : base.endsWith("/") ? base : `${base}/`;
+    this.storage = storage;
+  }
+  get path() {
+    return this.base === "/" ? "/" : this.base.slice(0, -1);
+  }
+  get tree() {
+    return this.storage;
+  }
+  // ─── Info ─────────────────────────────────────────────────
+  async info() {
+    return await this.storage.info({ path: this.path });
+  }
+  // ─── Get ──────────────────────────────────────────────────
+  async get({ name }) {
+    const path = `${this.base}${name}`;
+    return await this.storage.source({ path });
+  }
+  // ─── New ──────────────────────────────────────────────────
+  async newFolder({ name }) {
+    const path = `${this.base}${name}`;
+    return await this.storage.newFolder({ path });
+  }
+  async newFile({ name }) {
+    const path = `${this.base}${name}`;
+    return await this.storage.newFile({ path });
+  }
+  // ─── Refactor ─────────────────────────────────────────────
+  async rename({ name }) {
+    const path = this.base === "/" ? "/" : this.base.slice(0, -1);
+    const result = await this.storage.rename({ path, name });
+    if (!result.ok) return result;
+    const parentPath = path.substring(0, path.lastIndexOf("/")) || "/";
+    this.base = `${parentPath === "/" ? "" : parentPath}/${name}/`;
+    return { ok: true, error: null };
+  }
+  async copy({ to, merge, priority }) {
+    const result = await this.storage.copy({ fromPath: this.base, toPath: to, merge, priority });
+    if (!result.ok) return result;
+    return await this.storage.source({ path: to });
+  }
+  async move({ to, force }) {
+    const result = await this.storage.move({ fromPath: this.base, toPath: to, force });
+    if (!result.ok) return result;
+    const newInstance = await this.storage.source({ path: to });
+    if (newInstance instanceof _ExplorerFolder) this.base = newInstance.base;
+    return { ok: true, error: null };
+  }
+  async delete() {
+    return await this.storage.delete({ path: this.base });
+  }
+  async list({ recursive, limit, page, filter } = {}) {
+    return await this.storage.list({ path: this.path, recursive, limit, page, filter });
+  }
+  async exists() {
+    return await this.storage.exists({ path: this.path });
+  }
+  async size({ recursive, filter } = {}) {
+    return await this.storage.size({ path: this.path, recursive, filter });
+  }
+};
+
+// src/core/utils.ts
+function validatePath(oldPath) {
+  let path = oldPath;
+  if (!path.startsWith("/")) path = `/${path}`;
+  if (path.endsWith("/") && path !== "/") path = path.slice(0, -1);
+  if (path.trim() === "") return { newPath: oldPath, error: "Path cannot be empty" };
+  if (path.includes("//")) return { newPath: oldPath, error: 'Path cannot contain "//"' };
+  if (path.endsWith("/") && path !== "/") return { newPath: oldPath, error: 'Path cannot end with "/"' };
+  if (path.includes(" ")) return { newPath: oldPath, error: "Path cannot contain spaces" };
+  return { newPath: path, error: null };
+}
+
+// src/core/storage/idb-setup.ts
+var _IDBSetup = class _IDBSetup {
+  constructor({ name }) {
+    this.db = null;
+    this.dbName = name;
+  }
+  // ─── Helpers ───────────────────────────────────────────────
+  request(mode, fn) {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction("nodes", mode);
+      const store = transaction.objectStore("nodes");
+      const req = fn(store);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = (e) => reject(e.target.error);
+    });
+  }
+  transact(mode, fn) {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction("nodes", mode);
+      const store = transaction.objectStore("nodes");
+      fn(store);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = (e) => reject(e.target.error);
+    });
+  }
+  async pathTrated(path) {
+    if (path === "/") {
+      return {
+        path,
+        parent: null,
+        name: path,
+        table: await this.request("readonly", (store) => store.get(path))
+      };
+    }
+    ;
+    const { newPath, error } = validatePath(path);
+    if (error) throw new Error(error);
+    const pathParts = newPath.split("/");
+    const parent = pathParts.length === 2 ? "/" : pathParts.slice(0, -1).join("/");
+    const parentNode = await this.request("readonly", (store) => store.get(parent));
+    if (!parentNode) throw new Error(`Parent path "${parent}" does not exist`);
+    if (parentNode.type !== "folder") throw new Error(`Parent path "${parent}" is not a folder`);
+    const existingNode = await this.request("readonly", (store) => store.get(newPath));
+    return { path: newPath, parent, name: pathParts.pop(), table: existingNode };
+  }
+  async withWAL(data, action) {
+    await this.transact("readwrite", (store) => store.put({ ...data, status: "pending" }));
+    await action();
+    await this.transact("readwrite", (store) => store.put({ ...data, status: "ready" }));
+  }
+  // ─── init ──────────────────────────────────────────────────
+  openDB() {
+    const existing = _IDBSetup.registry.get(this.dbName);
+    if (existing) {
+      this.db = existing;
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, _IDBSetup.DB_VERSION);
+      request.onsuccess = (event) => {
+        this.db = event.target.result;
+        _IDBSetup.registry.set(this.dbName, this.db);
+        resolve();
+      };
+      request.onerror = (event) => {
+        reject(event.target.error);
+      };
+      request.onblocked = () => {
+        reject(new Error("IndexedDB blocked: close other tabs that are using the database."));
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (event.oldVersion < 1) {
+          const store = db.createObjectStore("nodes", { keyPath: "path" });
+          store.createIndex("type", "type");
+          store.createIndex("parent", "parent");
+          store.createIndex("contentId", "contentId", { unique: true });
+          store.createIndex("status", "status");
+        }
+      };
+    });
+  }
+  static close({ name }) {
+    const db = _IDBSetup.registry.get(name);
+    if (db) {
+      db.close();
+      _IDBSetup.registry.delete(name);
+    }
+  }
+};
+_IDBSetup.registry = /* @__PURE__ */ new Map();
+_IDBSetup.DB_VERSION = 1;
+var IDBSetup = _IDBSetup;
+
+// src/core/storage/opfs-storage.ts
+var OPFSStorage = class extends IDBSetup {
+  constructor(props) {
+    super(props);
+  }
+  async openStorage() {
+    this.root = await navigator.storage.getDirectory();
+    if (!this.root) throw new Error("Mensagem de erro");
+  }
+  async writeStorage(id, content) {
+    const fileHandle = await this.root.getFileHandle(id, { create: true });
+    const writable = await fileHandle.createWritable();
+    const data = typeof content === "object" && !(content instanceof ArrayBuffer) ? JSON.stringify(content) : content;
+    await writable.write(data);
+    await writable.close();
+  }
+  async readStorage(id) {
+    const fileHandle = await this.root.getFileHandle(id);
+    const file = await fileHandle.getFile();
+    return await file.arrayBuffer();
+  }
+  async readTextStorage(id) {
+    const fileHandle = await this.root.getFileHandle(id);
+    const file = await fileHandle.getFile();
+    return await file.text();
+  }
+  async deleteStorage(id) {
+    await this.root.removeEntry(id);
+  }
+  async existsStorage(id) {
+    try {
+      await this.root.getFileHandle(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/storage/idb-nodes.ts
+var IDBNodes = class extends OPFSStorage {
+  constructor(props) {
+    super(props);
+  }
+  async getSource(props) {
+    const propsTrated = await this.pathTrated(props.path);
+    if (!propsTrated.table) throw new Error(`Path ${props.path} does not exist`);
+    return propsTrated.table;
+  }
+  async addNode({ path, type }) {
+    if (type !== "file" && type !== "folder") throw new Error("Type must be 'file' or 'folder'");
+    if (path == "/") throw new Error("Should not create the root folder.");
+    const propsTrated = await this.pathTrated(path);
+    if (propsTrated.path === "/") throw new Error("Cannot add root node");
+    if (propsTrated.table && propsTrated.table.type !== type) throw new Error(`Path "${path}" already exists as a "${propsTrated.table.type}"`);
+    const now = Date.now();
+    const contentId = type === "file" ? String(crypto.getRandomValues(new Uint32Array(1))[0]) : void 0;
+    const node = {
+      path: propsTrated.path,
+      parent: propsTrated.parent,
+      type,
+      createdAt: propsTrated.table?.createdAt ?? now,
+      updatedAt: now,
+      ...contentId ? { contentId } : {}
+    };
+    await this.withWAL(node, async () => {
+      if (type === "file") await this.writeStorage(contentId, "");
+    });
+  }
+  async removeNode({ path }) {
+    if (path === "/") throw new Error("Cannot remove root node.");
+    const node = await this.getSource({ path });
+    if (node.type === "file") {
+      await this.transact("readwrite", (store) => store.delete(node.path));
+      await this.deleteStorage(node.contentId).catch(() => {
+      });
+      return;
+    }
+    if (node.type === "folder") {
+      const range = IDBKeyRange.bound(node.path + "/", node.path + "/\uFFFF");
+      const children = await this.request("readonly", (store) => store.getAll(range));
+      await this.transact("readwrite", (store) => {
+        store.delete(range);
+        store.delete(node.path);
+      });
+      for (const child of children) {
+        if (child.type === "file") {
+          await this.deleteStorage(child.contentId).catch(() => {
+          });
+        }
+      }
+      return;
+    }
+    throw new Error(`Unknown node type "${node.type}" at path "${path}".`);
+  }
+};
+
+// src/core/storage/idb-query.ts
+var IDBQuery = class extends IDBNodes {
+  constructor(props) {
+    super(props);
+  }
+  async existsNode({ path }) {
+    const norm = await this.pathTrated(path);
+    return !!norm.table;
+  }
+  async sizeNode({
+    pathRef,
+    recursive = false,
+    filter
+  }) {
+    const norm = await this.pathTrated(pathRef);
+    if (!norm.table) throw new Error(`Path "${pathRef}" does not exist`);
+    if (norm.table.type !== "folder") throw new Error(`Path "${pathRef}" is not a folder`);
+    const recursiveRange = norm.path === "/" ? IDBKeyRange.lowerBound("/", true) : IDBKeyRange.bound(norm.path + "/", norm.path + "/\uFFFF");
+    let count = 0;
+    await this.transact("readonly", (store) => {
+      const req = recursive ? store.openCursor(recursiveRange) : store.index("parent").openCursor(IDBKeyRange.only(norm.path));
+      req.onsuccess = (e) => {
+        const cursor = e.target.result;
+        if (!cursor) return;
+        const node = cursor.value;
+        if (node.status !== "pending") {
+          const item = { path: node.path, type: node.type, createdAt: node.createdAt, updatedAt: node.updatedAt };
+          if (!filter || filter(item)) count++;
+        }
+        cursor.continue();
+      };
+    });
+    return count;
+  }
+  async listNodes({
+    pathRef,
+    recursive = false,
+    limit = -1,
+    page = 0,
+    filter
+  }) {
+    const norm = await this.pathTrated(pathRef);
+    if (!norm.table) throw new Error(`Path "${pathRef}" does not exist`);
+    if (norm.table.type !== "folder") throw new Error(`Path "${pathRef}" is not a folder`);
+    const recursiveRange = norm.path === "/" ? IDBKeyRange.lowerBound("/", true) : IDBKeyRange.bound(norm.path + "/", norm.path + "/\uFFFF");
+    const results = [];
+    let toSkip = limit === -1 ? 0 : page * limit;
+    let count = 0;
+    await this.transact("readonly", ((store) => {
+      const req = recursive ? store.openCursor(recursiveRange) : store.index("parent").openCursor(IDBKeyRange.only(norm.path));
+      req.onsuccess = (e) => {
+        const cursor = e.target.result;
+        if (!cursor) return;
+        const node = cursor.value;
+        if (node.status === "pending") {
+          cursor.continue();
+          return;
+        }
+        const item = {
+          path: node.path,
+          type: node.type,
+          createdAt: node.createdAt,
+          updatedAt: node.updatedAt
+        };
+        if (filter && !filter(item)) {
+          cursor.continue();
+          return;
+        }
+        if (toSkip > 0) {
+          toSkip--;
+          cursor.continue();
+          return;
+        }
+        if (limit !== -1 && count >= limit) return;
+        results.push(item);
+        count++;
+        cursor.continue();
+      };
+    }));
+    return results;
+  }
+};
+
+// src/core/storage/idb-refactor.ts
+var IDBRefactor = class extends IDBQuery {
+  constructor(props) {
+    super(props);
+  }
+  async copyNode({
+    fromPath,
+    toPath,
+    merge = false,
+    priority = "source"
+  }) {
+    if (fromPath === "/" || toPath === "/") throw new Error("Cannot copy root node.");
+    if (fromPath === toPath) throw new Error("Cannot copy a node to itself.");
+    const fromEntity = await this.getSource({ path: fromPath });
+    const toEntityProps = await this.pathTrated(toPath);
+    const now = Date.now();
+    const remap = (oldPath) => toEntityProps.path + oldPath.slice(fromEntity.path.length);
+    const remapParent = (oldParent) => oldParent === null ? null : oldParent === fromEntity.path ? toEntityProps.path : remap(oldParent);
+    if (fromEntity.type === "file") {
+      if (priority === "destination" && !!toEntityProps.table) return;
+      const newContentId = String(crypto.getRandomValues(new Uint32Array(1))[0]);
+      const content = await this.readStorage(fromEntity.contentId);
+      await this.writeStorage(newContentId, content);
+      await this.transact("readwrite", (store) => {
+        if (toEntityProps.table) store.delete(toEntityProps.path);
+        store.put({
+          path: toEntityProps.path,
+          parent: toEntityProps.parent,
+          type: "file",
+          contentId: newContentId,
+          createdAt: fromEntity.createdAt,
+          updatedAt: now,
+          status: "ready"
+        });
+      });
+      if (toEntityProps.table?.type === "file") {
+        await this.deleteStorage(toEntityProps.table.contentId).catch(() => {
+        });
+      }
+      return;
+    }
+    if (fromEntity.type === "folder") {
+      const destExists = !!toEntityProps.table;
+      const destIsFile = toEntityProps.table?.type === "file";
+      if (priority === "destination" && !merge && destExists) return;
+      if (priority === "destination" && destIsFile) return;
+      const skipExisting = merge && priority === "destination";
+      const shouldReplaceDest = destExists && (!merge || destIsFile);
+      const sourceRange = IDBKeyRange.bound(fromEntity.path + "/", fromEntity.path + "/\uFFFF");
+      const sourceChildren = await this.request("readonly", (store) => store.getAll(sourceRange));
+      let destNodesToClean = [];
+      if (shouldReplaceDest) {
+        if (destIsFile && toEntityProps.table) {
+          destNodesToClean = [toEntityProps.table];
+        } else {
+          const destRange = IDBKeyRange.bound(toEntityProps.path + "/", toEntityProps.path + "/\uFFFF");
+          destNodesToClean = await this.request("readonly", (store) => store.getAll(destRange));
+        }
+      }
+      const foldersToCreate = [
+        { path: toEntityProps.path, parent: toEntityProps.parent, createdAt: toEntityProps.table?.createdAt ?? now }
+      ];
+      const filesToCopy = [];
+      for (const node of sourceChildren) {
+        if (node.status === "pending") continue;
+        const newPath = remap(node.path);
+        const newParent = remapParent(node.parent);
+        if (node.type === "folder") {
+          if (skipExisting && await this.existsNode({ path: newPath })) continue;
+          foldersToCreate.push({ path: newPath, parent: newParent, createdAt: node.createdAt });
+        } else if (node.type === "file") {
+          if (skipExisting && await this.existsNode({ path: newPath })) continue;
+          filesToCopy.push({
+            fromContentId: node.contentId,
+            newContentId: String(crypto.getRandomValues(new Uint32Array(1))[0]),
+            newPath,
+            newParent,
+            createdAt: node.createdAt
+          });
+        }
+      }
+      for (const file of filesToCopy) {
+        const content = await this.readStorage(file.fromContentId);
+        await this.writeStorage(file.newContentId, content);
+      }
+      await this.transact("readwrite", (store) => {
+        if (shouldReplaceDest) {
+          store.delete(toEntityProps.path);
+          if (!destIsFile) {
+            const destRange = IDBKeyRange.bound(toEntityProps.path + "/", toEntityProps.path + "/\uFFFF");
+            store.delete(destRange);
+          }
+        }
+        for (const folder of foldersToCreate) {
+          store.put({ path: folder.path, parent: folder.parent, type: "folder", createdAt: folder.createdAt, updatedAt: now, status: "ready" });
+        }
+        for (const file of filesToCopy) {
+          store.put({ path: file.newPath, parent: file.newParent, type: "file", contentId: file.newContentId, createdAt: file.createdAt, updatedAt: now, status: "ready" });
+        }
+      });
+      for (const node of destNodesToClean) {
+        if (node.type === "file") {
+          await this.deleteStorage(node.contentId).catch(() => {
+          });
+        }
+      }
+    }
+  }
+  async moveNode({
+    fromPath,
+    toPath,
+    force = false
+  }) {
+    if (fromPath === "/" || toPath === "/") throw new Error("Cannot move root node.");
+    const fromNorm = await this.pathTrated(fromPath);
+    const toNorm = await this.pathTrated(toPath);
+    if (fromNorm.path === toNorm.path) throw new Error("Cannot move a node to itself.");
+    if (toNorm.path.startsWith(fromNorm.path + "/")) throw new Error("Cannot move a folder into one of its own descendants.");
+    const fromEntity = await this.getSource({ path: fromPath });
+    const destExists = !!toNorm.table;
+    if (destExists) {
+      if (!force) throw new Error(`Destination "${toNorm.path}" already exists.`);
+      await this.removeNode({ path: toNorm.path });
+    }
+    const now = Date.now();
+    const remap = (oldPath) => toNorm.path + oldPath.slice(fromNorm.path.length);
+    const remapParent = (oldParent) => oldParent === null ? null : oldParent === fromNorm.path ? toNorm.path : remap(oldParent);
+    if (fromEntity.type === "file") {
+      await this.transact("readwrite", (store) => {
+        store.delete(fromNorm.path);
+        store.put({ ...fromEntity, path: toNorm.path, parent: toNorm.parent, updatedAt: now });
+      });
+      return;
+    }
+    if (fromEntity.type === "folder") {
+      const range = IDBKeyRange.bound(fromNorm.path + "/", fromNorm.path + "/\uFFFF");
+      const children = await this.request("readonly", (store) => store.getAll(range));
+      await this.transact("readwrite", (store) => {
+        store.delete(fromNorm.path);
+        store.put({ ...fromEntity, path: toNorm.path, parent: toNorm.parent, updatedAt: now });
+        for (const node of children) {
+          if (node.status === "pending") continue;
+          const newPath = remap(node.path);
+          const newParent = remapParent(node.parent);
+          store.delete(node.path);
+          store.put({ ...node, path: newPath, parent: newParent, updatedAt: now });
+        }
+      });
+    }
+  }
+};
+
+// src/core/storage/storage-init.ts
+var StorageInit = class extends IDBRefactor {
+  constructor(props) {
+    super(props);
+  }
+  async initExplorerData() {
+    await this.openDB();
+    await this.openStorage();
+    await this.recover();
+  }
+  async recover() {
+    await this.recoverPending();
+    await this.recoverOrphans();
+    await this.recoverBroken();
+  }
+  async recoverPending() {
+    const pending = await this.request(
+      "readonly",
+      (store) => store.index("status").getAll("pending")
+    );
+    for (const node of pending) {
+      await this.removeNode({ path: node.path });
+      if (node.type === "file") {
+        await this.deleteStorage(node.contentId).catch(() => {
+        });
+      }
+    }
+  }
+  async recoverOrphans() {
+    if (!(Symbol.asyncIterator in this.root)) return;
+    for await (const [name, handle] of this.root) {
+      if (handle.kind !== "file") continue;
+      const linked = await this.request(
+        "readonly",
+        (store) => store.index("contentId").get(name)
+      );
+      if (!linked) {
+        await this.deleteStorage(name).catch(() => {
+        });
+      }
+    }
+  }
+  async recoverBroken() {
+    const files = await this.request(
+      "readonly",
+      (store) => store.index("type").getAll("file")
+    );
+    for (const node of files) {
+      if (node.type !== "file") continue;
+      const exists = await this.existsStorage(node.contentId);
+      if (!exists) {
+        await this.removeNode({ path: node.path }).catch(() => {
+        });
+      }
+    }
+  }
+};
+
+// src/core/Explorer/ExplorerMain.ts
+var ExplorerTree = class _ExplorerTree extends StorageInit {
+  constructor(props) {
+    super(props);
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  subscribe(path, fn) {
+    if (!this.listeners.has(path)) this.listeners.set(path, /* @__PURE__ */ new Set());
+    this.listeners.get(path).add(fn);
+    return () => this.listeners.get(path)?.delete(fn);
+  }
+  parentOf(path) {
+    const idx = path.lastIndexOf("/");
+    if (idx <= 0) return "/";
+    return path.slice(0, idx);
+  }
+  notify(path) {
+    let current = path;
+    while (current !== null) {
+      this.listeners.get(current)?.forEach((fn) => fn());
+      if (current === "/") break;
+      current = this.parentOf(current);
+    }
+  }
+  static async create(props) {
+    const instance = new _ExplorerTree(props);
+    try {
+      await instance.initExplorerData();
+      const now = Date.now();
+      const existing = await instance.request("readonly", (store) => store.get("/"));
+      const objectPathRootInitialize = {
+        path: "/",
+        type: "folder",
+        parent: null,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        status: "ready"
+      };
+      await instance.transact("readwrite", (store) => store.put(objectPathRootInitialize));
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+    return instance;
+  }
+  // ─── Get ──────────────────────────────────────────────────
+  async source({ path }) {
+    try {
+      const table = await this.getSource({ path });
+      if (table.type === "folder") return new ExplorerFolder(table.path, this);
+      if (table.type === "file") return new ExplorerFile(table.path, this);
+      return { ok: false, error: `Internal error: entity at "${path}" has no valid type` };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  // ─── Info ─────────────────────────────────────────────────
+  async info({ path }) {
+    try {
+      const table = await this.getSource({ path });
+      return { ok: true, error: null, path: table.path, createdAt: table.createdAt, updatedAt: table.updatedAt };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async type({ path }) {
+    try {
+      const entity = await this.getSource({ path });
+      return entity.path === "/" ? "folder" : entity.type;
+    } catch (e) {
+      return null;
+    }
+  }
+  // ─── New ──────────────────────────────────────────────────
+  async newFolder({ path }) {
+    try {
+      await this.addNode({ path, type: "folder" });
+      this.notify(this.parentOf(path));
+      return new ExplorerFolder(path, this);
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async newFile({ path }) {
+    try {
+      await this.addNode({ path, type: "file" });
+      this.notify(this.parentOf(path));
+      return new ExplorerFile(path, this);
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  // ─── Refactor ─────────────────────────────────────────────
+  async delete({ path }) {
+    try {
+      const parent = this.parentOf(path);
+      await this.removeNode({ path });
+      this.notify(parent);
+      return { ok: true, error: null };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async copy({ fromPath, toPath, merge, priority }) {
+    try {
+      await this.copyNode({ fromPath, toPath, merge, priority });
+      this.notify(this.parentOf(toPath));
+      return { ok: true, error: null };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async move({ fromPath, toPath, force }) {
+    try {
+      await this.moveNode({ fromPath, toPath, force });
+      this.notify(this.parentOf(fromPath));
+      this.notify(this.parentOf(toPath));
+      return { ok: true, error: null };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async rename({ path, name }) {
+    try {
+      const normalized = await this.pathTrated(path);
+      const parent = normalized.parent ?? "/";
+      const toPath = `${parent === "/" ? "" : parent}/${name}`;
+      await this.moveNode({ fromPath: normalized.path, toPath });
+      this.notify(parent);
+      return { ok: true, error: null };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async list({ path, recursive, limit, page, filter }) {
+    try {
+      const items = await this.listNodes({ pathRef: path, recursive, limit, page, filter });
+      return { ok: true, error: null, items };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async exists({ path }) {
+    try {
+      return await this.existsNode({ path });
+    } catch {
+      return false;
+    }
+  }
+  async size({ path, recursive, filter }) {
+    try {
+      const size = await this.sizeNode({ pathRef: path, recursive, filter });
+      return { ok: true, error: null, size };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async write({ path, content }) {
+    try {
+      const tableByDB = await this.getSource({ path });
+      if (tableByDB.type === "folder") return { ok: false, error: `Path "${path}" is a folder` };
+      await this.writeStorage(tableByDB.contentId, content);
+      await this.transact("readwrite", (store) => store.put({ ...tableByDB, updatedAt: Date.now() }));
+      this.notify(path);
+      return { ok: true, error: null };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async read({ path }) {
+    try {
+      const tableByDB = await this.getSource({ path });
+      if (tableByDB.type === "folder") return { ok: false, error: `Path "${path}" is a folder` };
+      const content = await this.readStorage(tableByDB.contentId);
+      const text = new TextDecoder().decode(content);
+      return { ok: true, error: null, content, text };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  // zip. Talvez futuramente.
+  // Sync Github. Talvez futuramente.
+};
+
+export {
+  ExplorerFile,
+  ExplorerFolder,
+  ExplorerTree
+};
+//# sourceMappingURL=chunk-QOM3Q3WE.js.map