@bendyline/docblocks 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bendyline
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @bendyline/docblocks
+
+Core data structures and filesystem abstractions for DocBlocks.
+
+## Installation
+
+```bash
+npm install @bendyline/docblocks
+```
+
+## Exports
+
+The package provides two main modules:
+
+### Filesystem (`@bendyline/docblocks/filesystem`)
+
+Pluggable filesystem abstraction layer with multiple storage backends.
+
+- **`FileSystemProvider`** — Abstract interface for filesystem operations (`readFile`, `writeFile`, `readDirectory`, `delete`, `rename`, `createDirectory`, `stat`)
+- **`IndexedDBFileSystemProvider`** — Browser-based persistent storage using IndexedDB
+- **`NativeFileSystemProvider`** — Native filesystem access via the File System Access API
+- **`IndexedDBContentContainer`** — Content management layer for media and document storage
+
+```ts
+import { IndexedDBFileSystemProvider } from '@bendyline/docblocks/filesystem';
+
+const fs = new IndexedDBFileSystemProvider('my-workspace');
+await fs.writeFile('/doc.md', '# Hello');
+const content = await fs.readFile('/doc.md');
+```
+
+### Workspace (`@bendyline/docblocks/workspace`)
+
+Workspace management utilities for organizing document projects.
+
+- **`listWorkspaces`** — List all known workspaces
+- **`getWorkspace`** / **`saveWorkspace`** / **`removeWorkspace`** — CRUD operations
+- **`touchWorkspace`** — Update last-opened timestamp
+- **`ensureDefaultWorkspace`** — Create a default workspace if none exist
+
+```ts
+import { listWorkspaces, ensureDefaultWorkspace } from '@bendyline/docblocks/workspace';
+
+const workspaces = await listWorkspaces();
+```
+
+## License
+
+MIT

package/dist/chunk-GUNM43XZ.js

@@ -0,0 +1,63 @@
+// src/workspace/workspace-manager.ts
+import { LocalForageAdapter } from "@bendyline/squisq/storage";
+var DB_NAME = "docblocks-workspaces";
+var STORE_NAME = "workspaces";
+var LIST_KEY = "workspace-list";
+var DEFAULT_WORKSPACE_ID = "default";
+var store = new LocalForageAdapter({
+  name: DB_NAME,
+  storeName: STORE_NAME
+});
+async function listWorkspaces() {
+  const list = await store.get(LIST_KEY);
+  return list ?? [];
+}
+async function getWorkspace(id) {
+  const list = await listWorkspaces();
+  return list.find((w) => w.id === id) ?? null;
+}
+async function saveWorkspace(workspace) {
+  const list = await listWorkspaces();
+  const idx = list.findIndex((w) => w.id === workspace.id);
+  if (idx >= 0) {
+    list[idx] = workspace;
+  } else {
+    list.push(workspace);
+  }
+  await store.set(LIST_KEY, list);
+}
+async function removeWorkspace(id) {
+  const list = await listWorkspaces();
+  const filtered = list.filter((w) => w.id !== id);
+  await store.set(LIST_KEY, filtered);
+}
+async function touchWorkspace(id) {
+  const list = await listWorkspaces();
+  const workspace = list.find((w) => w.id === id);
+  if (workspace) {
+    workspace.lastOpened = (/* @__PURE__ */ new Date()).toISOString();
+    await store.set(LIST_KEY, list);
+  }
+}
+async function ensureDefaultWorkspace() {
+  const existing = await getWorkspace(DEFAULT_WORKSPACE_ID);
+  if (existing) return existing;
+  const descriptor = {
+    id: DEFAULT_WORKSPACE_ID,
+    name: "My Documents",
+    type: "indexeddb",
+    lastOpened: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveWorkspace(descriptor);
+  return descriptor;
+}
+
+export {
+  listWorkspaces,
+  getWorkspace,
+  saveWorkspace,
+  removeWorkspace,
+  touchWorkspace,
+  ensureDefaultWorkspace
+};
+//# sourceMappingURL=chunk-GUNM43XZ.js.map

package/dist/chunk-GUNM43XZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/workspace/workspace-manager.ts"],"sourcesContent":["/**\n * WorkspaceManager — manages the list of known workspaces in IndexedDB\n * and provides helpers for creating / switching / removing them.\n *\n * The actual FileSystemProvider instances are created by the caller\n * (since native providers need a DirectoryHandle from user interaction).\n */\n\nimport { LocalForageAdapter } from '@bendyline/squisq/storage';\nimport type { WorkspaceDescriptor } from './types.js';\n\nconst DB_NAME = 'docblocks-workspaces';\nconst STORE_NAME = 'workspaces';\nconst LIST_KEY = 'workspace-list';\nconst DEFAULT_WORKSPACE_ID = 'default';\n\nconst store = new LocalForageAdapter({\n  name: DB_NAME,\n  storeName: STORE_NAME,\n});\n\n/**\n * Get the list of all known workspace descriptors.\n */\nexport async function listWorkspaces(): Promise<WorkspaceDescriptor[]> {\n  const list = await store.get<WorkspaceDescriptor[]>(LIST_KEY);\n  return list ?? [];\n}\n\n/**\n * Get a specific workspace descriptor by id.\n */\nexport async function getWorkspace(id: string): Promise<WorkspaceDescriptor | null> {\n  const list = await listWorkspaces();\n  return list.find((w) => w.id === id) ?? null;\n}\n\n/**\n * Add or update a workspace descriptor. If a workspace with the same id\n * already exists, it is replaced.\n */\nexport async function saveWorkspace(workspace: WorkspaceDescriptor): Promise<void> {\n  const list = await listWorkspaces();\n  const idx = list.findIndex((w) => w.id === workspace.id);\n  if (idx >= 0) {\n    list[idx] = workspace;\n  } else {\n    list.push(workspace);\n  }\n  await store.set(LIST_KEY, list);\n}\n\n/**\n * Remove a workspace descriptor by id.\n */\nexport async function removeWorkspace(id: string): Promise<void> {\n  const list = await listWorkspaces();\n  const filtered = list.filter((w) => w.id !== id);\n  await store.set(LIST_KEY, filtered);\n}\n\n/**\n * Touch the lastOpened timestamp on a workspace.\n */\nexport async function touchWorkspace(id: string): Promise<void> {\n  const list = await listWorkspaces();\n  const workspace = list.find((w) => w.id === id);\n  if (workspace) {\n    workspace.lastOpened = new Date().toISOString();\n    await store.set(LIST_KEY, list);\n  }\n}\n\n/**\n * Ensure a default IndexedDB workspace exists. Called on app startup.\n * Returns the descriptor.\n */\nexport async function ensureDefaultWorkspace(): Promise<WorkspaceDescriptor> {\n  const existing = await getWorkspace(DEFAULT_WORKSPACE_ID);\n  if (existing) return existing;\n\n  const descriptor: WorkspaceDescriptor = {\n    id: DEFAULT_WORKSPACE_ID,\n    name: 'My Documents',\n    type: 'indexeddb',\n    lastOpened: new Date().toISOString(),\n  };\n  await saveWorkspace(descriptor);\n  return descriptor;\n}\n"],"mappings":";AAQA,SAAS,0BAA0B;AAGnC,IAAM,UAAU;AAChB,IAAM,aAAa;AACnB,IAAM,WAAW;AACjB,IAAM,uBAAuB;AAE7B,IAAM,QAAQ,IAAI,mBAAmB;AAAA,EACnC,MAAM;AAAA,EACN,WAAW;AACb,CAAC;AAKD,eAAsB,iBAAiD;AACrE,QAAM,OAAO,MAAM,MAAM,IAA2B,QAAQ;AAC5D,SAAO,QAAQ,CAAC;AAClB;AAKA,eAAsB,aAAa,IAAiD;AAClF,QAAM,OAAO,MAAM,eAAe;AAClC,SAAO,KAAK,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK;AAC1C;AAMA,eAAsB,cAAc,WAA+C;AACjF,QAAM,OAAO,MAAM,eAAe;AAClC,QAAM,MAAM,KAAK,UAAU,CAAC,MAAM,EAAE,OAAO,UAAU,EAAE;AACvD,MAAI,OAAO,GAAG;AACZ,SAAK,GAAG,IAAI;AAAA,EACd,OAAO;AACL,SAAK,KAAK,SAAS;AAAA,EACrB;AACA,QAAM,MAAM,IAAI,UAAU,IAAI;AAChC;AAKA,eAAsB,gBAAgB,IAA2B;AAC/D,QAAM,OAAO,MAAM,eAAe;AAClC,QAAM,WAAW,KAAK,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE;AAC/C,QAAM,MAAM,IAAI,UAAU,QAAQ;AACpC;AAKA,eAAsB,eAAe,IAA2B;AAC9D,QAAM,OAAO,MAAM,eAAe;AAClC,QAAM,YAAY,KAAK,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE;AAC9C,MAAI,WAAW;AACb,cAAU,cAAa,oBAAI,KAAK,GAAE,YAAY;AAC9C,UAAM,MAAM,IAAI,UAAU,IAAI;AAAA,EAChC;AACF;AAMA,eAAsB,yBAAuD;AAC3E,QAAM,WAAW,MAAM,aAAa,oBAAoB;AACxD,MAAI,SAAU,QAAO;AAErB,QAAM,aAAkC;AAAA,IACtC,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,MAAM;AAAA,IACN,aAAY,oBAAI,KAAK,GAAE,YAAY;AAAA,EACrC;AACA,QAAM,cAAc,UAAU;AAC9B,SAAO;AACT;","names":[]}

package/dist/chunk-NSVTXALR.js

@@ -0,0 +1,559 @@
+// src/filesystem/indexeddb-provider.ts
+import { LocalForageAdapter } from "@bendyline/squisq/storage";
+function normalisePath(p) {
+  return p.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "");
+}
+function parentDir(p) {
+  const idx = p.lastIndexOf("/");
+  return idx === -1 ? "" : p.slice(0, idx);
+}
+function baseName(p) {
+  const idx = p.lastIndexOf("/");
+  return idx === -1 ? p : p.slice(idx + 1);
+}
+function contentKey(path) {
+  return `fs:${path}:content`;
+}
+function binaryKey(path) {
+  return `fs:${path}:binary`;
+}
+function metaKey(path) {
+  return `fs:${path}:meta`;
+}
+var DIRS_KEY = "fs:dirs";
+var IndexedDBFileSystemProvider = class {
+  constructor(id, label) {
+    this.id = id;
+    this.label = label;
+    this.store = new LocalForageAdapter({
+      name: `docblocks-fs-${id}`,
+      storeName: "files"
+    });
+  }
+  // ── Directory tracking ──────────────────────────────────────────
+  async getDirs() {
+    const raw = await this.store.get(DIRS_KEY);
+    return new Set(raw ?? []);
+  }
+  async saveDirs(dirs) {
+    await this.store.set(DIRS_KEY, [...dirs]);
+  }
+  /** Ensure a directory (and all ancestors) are tracked. */
+  async ensureDir(dirPath) {
+    if (!dirPath) return;
+    const dirs = await this.getDirs();
+    const parts = dirPath.split("/");
+    let current = "";
+    let changed = false;
+    for (const part of parts) {
+      current = current ? `${current}/${part}` : part;
+      if (!dirs.has(current)) {
+        dirs.add(current);
+        changed = true;
+      }
+    }
+    if (changed) {
+      await this.saveDirs(dirs);
+    }
+  }
+  // ── FileSystemProvider implementation ───────────────────────────
+  async readFile(path) {
+    const p = normalisePath(path);
+    return this.store.get(contentKey(p));
+  }
+  async writeFile(path, content) {
+    const p = normalisePath(path);
+    const parent = parentDir(p);
+    if (parent) {
+      await this.ensureDir(parent);
+    }
+    const meta = {
+      name: baseName(p),
+      path: p,
+      size: new Blob([content]).size,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.store.set(contentKey(p), content);
+    await this.store.set(metaKey(p), meta);
+  }
+  async delete(path) {
+    const p = normalisePath(path);
+    await this.store.remove(contentKey(p));
+    await this.store.remove(binaryKey(p));
+    await this.store.remove(metaKey(p));
+    const dirs = await this.getDirs();
+    if (dirs.has(p)) {
+      const prefix = p + "/";
+      const toRemove = [p];
+      for (const d of dirs) {
+        if (d.startsWith(prefix)) {
+          toRemove.push(d);
+        }
+      }
+      for (const d of toRemove) {
+        dirs.delete(d);
+      }
+      await this.saveDirs(dirs);
+      const allKeys = await this.store.keys();
+      const filePrefix = `fs:${p}/`;
+      const keysToRemove = allKeys.filter((k) => k.startsWith(filePrefix));
+      await Promise.all(keysToRemove.map((k) => this.store.remove(k)));
+    }
+  }
+  async rename(oldPath, newPath) {
+    const op = normalisePath(oldPath);
+    const np = normalisePath(newPath);
+    const content = await this.store.get(contentKey(op));
+    const binary = await this.store.get(binaryKey(op));
+    const meta = await this.store.get(metaKey(op));
+    if (content !== null) {
+      await this.store.set(contentKey(np), content);
+    }
+    if (binary !== null) {
+      await this.store.set(binaryKey(np), binary);
+    }
+    if (meta) {
+      meta.name = baseName(np);
+      meta.path = np;
+      await this.store.set(metaKey(np), meta);
+    }
+    const newParent = parentDir(np);
+    if (newParent) {
+      await this.ensureDir(newParent);
+    }
+    await this.store.remove(contentKey(op));
+    await this.store.remove(binaryKey(op));
+    await this.store.remove(metaKey(op));
+    const dirs = await this.getDirs();
+    if (dirs.has(op)) {
+      dirs.delete(op);
+      dirs.add(np);
+      const oldPrefix = op + "/";
+      const newPrefix = np + "/";
+      for (const d of [...dirs]) {
+        if (d.startsWith(oldPrefix)) {
+          dirs.delete(d);
+          dirs.add(newPrefix + d.slice(oldPrefix.length));
+        }
+      }
+      await this.saveDirs(dirs);
+    }
+  }
+  async readDirectory(path) {
+    const p = normalisePath(path);
+    const dirs = await this.getDirs();
+    const entries = [];
+    const seen = /* @__PURE__ */ new Set();
+    const prefix = p ? p + "/" : "";
+    for (const d of dirs) {
+      if (!p && !d.includes("/")) {
+        if (!seen.has(d)) {
+          seen.add(d);
+          entries.push({ kind: "directory", name: d, path: d });
+        }
+      } else if (p && d.startsWith(prefix)) {
+        const rest = d.slice(prefix.length);
+        if (!rest.includes("/")) {
+          if (!seen.has(rest)) {
+            seen.add(rest);
+            entries.push({ kind: "directory", name: rest, path: d });
+          }
+        }
+      }
+    }
+    const allKeys = await this.store.keys();
+    const metaPrefix = p ? `fs:${p}/` : "fs:";
+    const metaSuffix = ":meta";
+    for (const key of allKeys) {
+      if (!key.startsWith(metaPrefix) || !key.endsWith(metaSuffix)) continue;
+      const filePath = key.slice(3, -metaSuffix.length);
+      const rel = p ? filePath.slice(prefix.length) : filePath;
+      if (rel.includes("/")) continue;
+      if (!seen.has(rel)) {
+        seen.add(rel);
+        entries.push({ kind: "file", name: rel, path: filePath });
+      }
+    }
+    entries.sort((a, b) => {
+      if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return entries;
+  }
+  async exists(path) {
+    const p = normalisePath(path);
+    const dirs = await this.getDirs();
+    if (dirs.has(p)) return true;
+    const meta = await this.store.get(metaKey(p));
+    return meta !== null;
+  }
+  async createDirectory(path) {
+    const p = normalisePath(path);
+    await this.ensureDir(p);
+  }
+  async stat(path) {
+    const p = normalisePath(path);
+    return this.store.get(metaKey(p));
+  }
+  async readBinary(path) {
+    const p = normalisePath(path);
+    return this.store.get(binaryKey(p));
+  }
+  async writeBinary(path, data) {
+    const p = normalisePath(path);
+    const parent = parentDir(p);
+    if (parent) {
+      await this.ensureDir(parent);
+    }
+    const meta = {
+      name: baseName(p),
+      path: p,
+      size: data.byteLength,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.store.set(binaryKey(p), data);
+    await this.store.set(metaKey(p), meta);
+  }
+};
+
+// src/filesystem/indexeddb-content-container.ts
+import { findDocumentPath } from "@bendyline/squisq/storage";
+var EXTENSION_MIME_MAP = {
+  ".md": "text/markdown",
+  ".txt": "text/plain",
+  ".json": "application/json",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg"
+};
+function guessMimeType(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot === -1) return "application/octet-stream";
+  const ext = path.slice(dot).toLowerCase();
+  return EXTENSION_MIME_MAP[ext] ?? "application/octet-stream";
+}
+var IndexedDBContentContainer = class {
+  constructor(workspaceId) {
+    this.provider = new IndexedDBFileSystemProvider(`${workspaceId}-media`, "Media Storage");
+  }
+  async readFile(path) {
+    return this.provider.readBinary(path);
+  }
+  async writeFile(path, data, _mimeType) {
+    await this.provider.writeBinary(path, data);
+  }
+  async removeFile(path) {
+    await this.provider.delete(path);
+  }
+  async listFiles(prefix) {
+    const entries = [];
+    const walk = async (dir) => {
+      const children = await this.provider.readDirectory(dir);
+      for (const child of children) {
+        if (child.kind === "directory") {
+          await walk(child.path);
+        } else {
+          const filePath = child.path.replace(/^\//, "");
+          if (prefix && !filePath.startsWith(prefix)) continue;
+          const meta = await this.provider.stat(child.path);
+          entries.push({
+            path: filePath,
+            mimeType: guessMimeType(filePath),
+            size: meta?.size ?? 0
+          });
+        }
+      }
+    };
+    await walk("/");
+    return entries;
+  }
+  async exists(path) {
+    return this.provider.exists(path);
+  }
+  async getDocumentPath() {
+    return findDocumentPath(await this.listFiles());
+  }
+  async readDocument() {
+    const docPath = await this.getDocumentPath();
+    if (!docPath) return null;
+    const data = await this.readFile(docPath);
+    if (!data) return null;
+    return new TextDecoder().decode(data);
+  }
+  async writeDocument(markdown, filename) {
+    const name = filename ?? "index.md";
+    const data = new TextEncoder().encode(markdown);
+    await this.writeFile(name, data, "text/markdown");
+  }
+};
+
+// src/filesystem/native-provider.ts
+function isNativeFileSystemSupported() {
+  return typeof globalThis !== "undefined" && "showDirectoryPicker" in globalThis;
+}
+var HANDLE_DB_NAME = "docblocks-handles";
+var HANDLE_STORE_NAME = "directory-handles";
+function openHandleDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(HANDLE_DB_NAME, 1);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore(HANDLE_STORE_NAME);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function storeDirectoryHandle(workspaceId, handle) {
+  const db = await openHandleDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(HANDLE_STORE_NAME, "readwrite");
+    tx.objectStore(HANDLE_STORE_NAME).put(handle, workspaceId);
+    tx.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    tx.onerror = () => {
+      db.close();
+      reject(tx.error);
+    };
+  });
+}
+async function loadDirectoryHandle(workspaceId) {
+  const db = await openHandleDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(HANDLE_STORE_NAME, "readonly");
+    const req = tx.objectStore(HANDLE_STORE_NAME).get(workspaceId);
+    req.onsuccess = () => {
+      db.close();
+      resolve(req.result ?? null);
+    };
+    req.onerror = () => {
+      db.close();
+      reject(req.error);
+    };
+  });
+}
+async function removeDirectoryHandle(workspaceId) {
+  const db = await openHandleDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(HANDLE_STORE_NAME, "readwrite");
+    tx.objectStore(HANDLE_STORE_NAME).delete(workspaceId);
+    tx.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    tx.onerror = () => {
+      db.close();
+      reject(tx.error);
+    };
+  });
+}
+function normalisePath2(p) {
+  return p.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "");
+}
+async function resolveDir(root, dirPath) {
+  if (!dirPath) return root;
+  const parts = dirPath.split("/");
+  let current = root;
+  for (const part of parts) {
+    try {
+      current = await current.getDirectoryHandle(part);
+    } catch {
+      return null;
+    }
+  }
+  return current;
+}
+async function resolveDirCreate(root, dirPath) {
+  if (!dirPath) return root;
+  const parts = dirPath.split("/");
+  let current = root;
+  for (const part of parts) {
+    current = await current.getDirectoryHandle(part, { create: true });
+  }
+  return current;
+}
+function parentDir2(p) {
+  const idx = p.lastIndexOf("/");
+  return idx === -1 ? "" : p.slice(0, idx);
+}
+function baseName2(p) {
+  const idx = p.lastIndexOf("/");
+  return idx === -1 ? p : p.slice(idx + 1);
+}
+var NativeFileSystemProvider = class {
+  constructor(id, root) {
+    this.id = id;
+    this.label = root.name;
+    this.root = root;
+  }
+  async readFile(path) {
+    const p = normalisePath2(path);
+    const dir = await resolveDir(this.root, parentDir2(p));
+    if (!dir) return null;
+    try {
+      const fileHandle = await dir.getFileHandle(baseName2(p));
+      const file = await fileHandle.getFile();
+      return file.text();
+    } catch {
+      return null;
+    }
+  }
+  async writeFile(path, content) {
+    const p = normalisePath2(path);
+    const dir = await resolveDirCreate(this.root, parentDir2(p));
+    const fileHandle = await dir.getFileHandle(baseName2(p), { create: true });
+    const writable = await fileHandle.createWritable();
+    await writable.write(content);
+    await writable.close();
+  }
+  async delete(path) {
+    const p = normalisePath2(path);
+    const parent = parentDir2(p);
+    const name = baseName2(p);
+    const dir = await resolveDir(this.root, parent);
+    if (!dir) return;
+    await dir.removeEntry(name, { recursive: true });
+  }
+  async rename(oldPath, newPath) {
+    const op = normalisePath2(oldPath);
+    const np = normalisePath2(newPath);
+    const content = await this.readFile(op);
+    if (content !== null) {
+      await this.writeFile(np, content);
+      await this.delete(op);
+      return;
+    }
+    const binary = await this.readBinary(op);
+    if (binary !== null) {
+      await this.writeBinary(np, binary);
+      await this.delete(op);
+    }
+  }
+  async readDirectory(path) {
+    const p = normalisePath2(path);
+    const dir = await resolveDir(this.root, p);
+    if (!dir) return [];
+    const entries = [];
+    for await (const [name, handle] of dir) {
+      const entryPath = p ? `${p}/${name}` : name;
+      if (handle.kind === "directory") {
+        entries.push({ kind: "directory", name, path: entryPath });
+      } else {
+        entries.push({ kind: "file", name, path: entryPath });
+      }
+    }
+    entries.sort((a, b) => {
+      if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return entries;
+  }
+  async exists(path) {
+    const p = normalisePath2(path);
+    const parent = parentDir2(p);
+    const name = baseName2(p);
+    const dir = await resolveDir(this.root, parent);
+    if (!dir) return false;
+    try {
+      await dir.getFileHandle(name);
+      return true;
+    } catch {
+      try {
+        await dir.getDirectoryHandle(name);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  async createDirectory(path) {
+    const p = normalisePath2(path);
+    await resolveDirCreate(this.root, p);
+  }
+  async stat(path) {
+    const p = normalisePath2(path);
+    const dir = await resolveDir(this.root, parentDir2(p));
+    if (!dir) return null;
+    try {
+      const fileHandle = await dir.getFileHandle(baseName2(p));
+      const file = await fileHandle.getFile();
+      return {
+        name: file.name,
+        path: p,
+        size: file.size,
+        lastModified: new Date(file.lastModified).toISOString()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async readBinary(path) {
+    const p = normalisePath2(path);
+    const dir = await resolveDir(this.root, parentDir2(p));
+    if (!dir) return null;
+    try {
+      const fileHandle = await dir.getFileHandle(baseName2(p));
+      const file = await fileHandle.getFile();
+      return file.arrayBuffer();
+    } catch {
+      return null;
+    }
+  }
+  async writeBinary(path, data) {
+    const p = normalisePath2(path);
+    const dir = await resolveDirCreate(this.root, parentDir2(p));
+    const fileHandle = await dir.getFileHandle(baseName2(p), { create: true });
+    const writable = await fileHandle.createWritable();
+    if (data instanceof ArrayBuffer) {
+      await writable.write(data);
+    } else {
+      await writable.write(data.buffer);
+    }
+    await writable.close();
+  }
+};
+async function openNativeFolder() {
+  if (!isNativeFileSystemSupported()) {
+    throw new Error("File System Access API is not supported in this browser");
+  }
+  const handle = await globalThis.showDirectoryPicker();
+  const id = `native-${handle.name}-${Date.now()}`;
+  await storeDirectoryHandle(id, handle);
+  return new NativeFileSystemProvider(id, handle);
+}
+async function restoreNativeFolder(workspaceId) {
+  const handle = await loadDirectoryHandle(workspaceId);
+  if (!handle) return null;
+  const opts = { mode: "readwrite" };
+  const h = handle;
+  if (await h.queryPermission(opts) === "granted") {
+    return new NativeFileSystemProvider(workspaceId, handle);
+  }
+  if (await h.requestPermission(opts) === "granted") {
+    return new NativeFileSystemProvider(workspaceId, handle);
+  }
+  return null;
+}
+
+export {
+  IndexedDBFileSystemProvider,
+  IndexedDBContentContainer,
+  isNativeFileSystemSupported,
+  storeDirectoryHandle,
+  loadDirectoryHandle,
+  removeDirectoryHandle,
+  NativeFileSystemProvider,
+  openNativeFolder,
+  restoreNativeFolder
+};
+//# sourceMappingURL=chunk-NSVTXALR.js.map