@b9g/filesystem 0.1.0

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@b9g/filesystem",
+  "version": "0.1.0",
+  "description": "Universal File System Access API implementations for all platforms",
+  "license": "MIT",
+  "devDependencies": {
+    "@b9g/libuild": "^0.1.10",
+    "@types/bun": "^1.2.2"
+  },
+  "peerDependencies": {
+    "@types/wicg-file-system-access": "^2023.10.7"
+  },
+  "type": "module",
+  "types": "src/index.d.ts",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./bun-s3": {
+      "types": "./src/bun-s3.d.ts",
+      "import": "./src/bun-s3.js"
+    },
+    "./bun-s3.js": {
+      "types": "./src/bun-s3.d.ts",
+      "import": "./src/bun-s3.js"
+    },
+    "./index": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./index.js": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./memory": {
+      "types": "./src/memory.d.ts",
+      "import": "./src/memory.js"
+    },
+    "./memory.js": {
+      "types": "./src/memory.d.ts",
+      "import": "./src/memory.js"
+    },
+    "./node": {
+      "types": "./src/node.d.ts",
+      "import": "./src/node.js"
+    },
+    "./node.js": {
+      "types": "./src/node.d.ts",
+      "import": "./src/node.js"
+    },
+    "./registry": {
+      "types": "./src/registry.d.ts",
+      "import": "./src/registry.js"
+    },
+    "./registry.js": {
+      "types": "./src/registry.d.ts",
+      "import": "./src/registry.js"
+    },
+    "./types": {
+      "types": "./src/types.d.ts",
+      "import": "./src/types.js"
+    },
+    "./types.js": {
+      "types": "./src/types.d.ts",
+      "import": "./src/types.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/src/bun-s3.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Bun S3 implementation of File System Access API using built-in S3 support
+ *
+ * Leverages Bun's native S3Client and S3File for high-performance
+ * cloud storage operations with File System Access API compatibility.
+ */
+import type { FileSystemAdapter, FileSystemConfig } from "@b9g/filesystem";
+/**
+ * Bun S3 implementation of FileSystemWritableFileStream
+ */
+export declare class BunS3FileSystemWritableFileStream extends WritableStream<Uint8Array> {
+    private s3file;
+    private writer;
+    constructor(s3file: any);
+}
+/**
+ * Bun S3 implementation of FileSystemFileHandle
+ */
+export declare class BunS3FileSystemFileHandle implements FileSystemFileHandle {
+    private s3Client;
+    private key;
+    readonly kind: "file";
+    readonly name: string;
+    constructor(s3Client: any, // Bun S3Client
+    key: string);
+    getFile(): Promise<File>;
+    createWritable(): Promise<FileSystemWritableFileStream>;
+    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
+    isSameEntry(other: FileSystemHandle): Promise<boolean>;
+    queryPermission(): Promise<PermissionState>;
+    requestPermission(): Promise<PermissionState>;
+    private getMimeType;
+}
+/**
+ * Bun S3 implementation of FileSystemDirectoryHandle
+ */
+export declare class BunS3FileSystemDirectoryHandle implements FileSystemDirectoryHandle {
+    private s3Client;
+    private prefix;
+    readonly kind: "directory";
+    readonly name: string;
+    constructor(s3Client: any, // Bun S3Client
+    prefix: string);
+    getFileHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemFileHandle>;
+    getDirectoryHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemDirectoryHandle>;
+    removeEntry(name: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
+    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
+    keys(): AsyncIterableIterator<string>;
+    values(): AsyncIterableIterator<FileSystemHandle>;
+    isSameEntry(other: FileSystemHandle): Promise<boolean>;
+    queryPermission(): Promise<PermissionState>;
+    requestPermission(): Promise<PermissionState>;
+}
+/**
+ * Bun S3 filesystem adapter using Bun's native S3Client
+ */
+export declare class BunS3FileSystemAdapter implements FileSystemAdapter {
+    private config;
+    private s3Client;
+    constructor(s3Client: any, config?: FileSystemConfig);
+    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    getConfig(): FileSystemConfig;
+    dispose(): Promise<void>;
+}

package/src/bun-s3.js

@@ -0,0 +1,244 @@
+/// <reference types="./bun-s3.d.ts" />
+// src/bun-s3.ts
+var BunS3FileSystemWritableFileStream = class extends WritableStream {
+  constructor(s3file) {
+    super({
+      start: async () => {
+        this.writer = this.s3file.writer();
+      },
+      write: async (chunk) => {
+        await this.writer.write(chunk);
+      },
+      close: async () => {
+        await this.writer.end();
+      },
+      abort: async () => {
+        await this.writer.abort?.();
+      }
+    });
+    this.s3file = s3file;
+  }
+  writer;
+};
+var BunS3FileSystemFileHandle = class _BunS3FileSystemFileHandle {
+  constructor(s3Client, key) {
+    this.s3Client = s3Client;
+    this.key = key;
+    this.name = key.split("/").pop() || key;
+  }
+  kind = "file";
+  name;
+  async getFile() {
+    const s3file = this.s3Client.file(this.key);
+    try {
+      const exists = await s3file.exists();
+      if (!exists) {
+        throw new DOMException("File not found", "NotFoundError");
+      }
+      const stats = await s3file.stat();
+      const blob = s3file;
+      return new File([blob], this.name, {
+        lastModified: stats?.lastModified ? new Date(stats.lastModified).getTime() : Date.now(),
+        type: stats?.contentType || this.getMimeType(this.key)
+      });
+    } catch (error) {
+      if (error.message?.includes("NoSuchKey") || error.message?.includes("Not Found")) {
+        throw new DOMException("File not found", "NotFoundError");
+      }
+      throw error;
+    }
+  }
+  async createWritable() {
+    const s3file = this.s3Client.file(this.key);
+    return new BunS3FileSystemWritableFileStream(s3file);
+  }
+  async createSyncAccessHandle() {
+    throw new DOMException(
+      "Synchronous access handles are not supported for S3 storage",
+      "InvalidStateError"
+    );
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "file")
+      return false;
+    if (!(other instanceof _BunS3FileSystemFileHandle))
+      return false;
+    return this.key === other.key;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+  getMimeType(key) {
+    const ext = key.split(".").pop()?.toLowerCase();
+    const mimeTypes = {
+      txt: "text/plain",
+      html: "text/html",
+      css: "text/css",
+      js: "text/javascript",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      pdf: "application/pdf",
+      zip: "application/zip"
+    };
+    return mimeTypes[ext || ""] || "application/octet-stream";
+  }
+};
+var BunS3FileSystemDirectoryHandle = class _BunS3FileSystemDirectoryHandle {
+  constructor(s3Client, prefix) {
+    this.s3Client = s3Client;
+    this.prefix = prefix;
+    this.prefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+    this.name = this.prefix.split("/").pop() || "root";
+  }
+  kind = "directory";
+  name;
+  async getFileHandle(name, options) {
+    const key = this.prefix ? `${this.prefix}/${name}` : name;
+    const s3file = this.s3Client.file(key);
+    const exists = await s3file.exists();
+    if (!exists && options?.create) {
+      await s3file.write("");
+    } else if (!exists) {
+      throw new DOMException("File not found", "NotFoundError");
+    }
+    return new BunS3FileSystemFileHandle(this.s3Client, key);
+  }
+  async getDirectoryHandle(name, options) {
+    const newPrefix = this.prefix ? `${this.prefix}/${name}` : name;
+    if (options?.create) {
+      const markerKey = `${newPrefix}/.shovel_directory_marker`;
+      const markerFile = this.s3Client.file(markerKey);
+      const exists = await markerFile.exists();
+      if (!exists) {
+        await markerFile.write("");
+      }
+    }
+    return new _BunS3FileSystemDirectoryHandle(this.s3Client, newPrefix);
+  }
+  async removeEntry(name, options) {
+    const key = this.prefix ? `${this.prefix}/${name}` : name;
+    const s3file = this.s3Client.file(key);
+    const fileExists = await s3file.exists();
+    if (fileExists) {
+      await s3file.delete();
+      return;
+    }
+    if (options?.recursive) {
+      const dirPrefix = `${key}/`;
+      const files = await this.s3Client.list({ prefix: dirPrefix });
+      const deletePromises = files.map(
+        (file) => this.s3Client.file(file.Key || file.key).delete()
+      );
+      await Promise.all(deletePromises);
+      const markerFile = this.s3Client.file(`${key}/.shovel_directory_marker`);
+      const markerExists = await markerFile.exists();
+      if (markerExists) {
+        await markerFile.delete();
+      }
+    } else {
+      throw new DOMException(
+        "Directory is not empty",
+        "InvalidModificationError"
+      );
+    }
+  }
+  async resolve(_possibleDescendant) {
+    return null;
+  }
+  async *entries() {
+    const listPrefix = this.prefix ? `${this.prefix}/` : "";
+    try {
+      const result = await this.s3Client.list({
+        prefix: listPrefix,
+        delimiter: "/"
+        // Only get immediate children
+      });
+      if (result.Contents) {
+        for (const item of result.Contents) {
+          const key = item.Key || item.key;
+          if (key && key !== listPrefix) {
+            const name = key.substring(listPrefix.length);
+            if (!name.includes("/") && !name.endsWith(".shovel_directory_marker")) {
+              yield [name, new BunS3FileSystemFileHandle(this.s3Client, key)];
+            }
+          }
+        }
+      }
+      if (result.CommonPrefixes) {
+        for (const prefix of result.CommonPrefixes) {
+          const prefixKey = prefix.Prefix || prefix.prefix;
+          if (prefixKey) {
+            const name = prefixKey.substring(listPrefix.length).replace(/\/$/, "");
+            if (name) {
+              yield [
+                name,
+                new _BunS3FileSystemDirectoryHandle(
+                  this.s3Client,
+                  prefixKey.replace(/\/$/, "")
+                )
+              ];
+            }
+          }
+        }
+      }
+    } catch (error) {
+      throw new DOMException("Directory not found", "NotFoundError");
+    }
+  }
+  async *keys() {
+    for await (const [name] of this.entries()) {
+      yield name;
+    }
+  }
+  async *values() {
+    for await (const [, handle] of this.entries()) {
+      yield handle;
+    }
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "directory")
+      return false;
+    if (!(other instanceof _BunS3FileSystemDirectoryHandle))
+      return false;
+    return this.prefix === other.prefix;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+};
+var BunS3FileSystemAdapter = class {
+  config;
+  s3Client;
+  constructor(s3Client, config = {}) {
+    this.config = {
+      name: "bun-s3",
+      ...config
+    };
+    this.s3Client = s3Client;
+  }
+  async getFileSystemRoot(name = "default") {
+    const prefix = `filesystems/${name}`;
+    return new BunS3FileSystemDirectoryHandle(this.s3Client, prefix);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  async dispose() {
+  }
+};
+export {
+  BunS3FileSystemAdapter,
+  BunS3FileSystemDirectoryHandle,
+  BunS3FileSystemFileHandle,
+  BunS3FileSystemWritableFileStream
+};

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export type { FileSystemAdapter, FileSystemConfig } from "./types.js";
+export { MemoryFileSystemAdapter } from "./memory.js";
+export { NodeFileSystemAdapter, NodeFileSystemDirectoryHandle, NodeFileSystemFileHandle } from "./node.js";
+export { BunS3FileSystemAdapter, BunS3FileSystemDirectoryHandle, BunS3FileSystemFileHandle } from "./bun-s3.js";
+export { FileSystemRegistry, getFileSystemRoot } from "./registry.js";

package/src/index.js

@@ -0,0 +1,17 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+import { MemoryFileSystemAdapter } from "./memory.js";
+import { NodeFileSystemAdapter, NodeFileSystemDirectoryHandle, NodeFileSystemFileHandle } from "./node.js";
+import { BunS3FileSystemAdapter, BunS3FileSystemDirectoryHandle, BunS3FileSystemFileHandle } from "./bun-s3.js";
+import { FileSystemRegistry, getFileSystemRoot } from "./registry.js";
+export {
+  BunS3FileSystemAdapter,
+  BunS3FileSystemDirectoryHandle,
+  BunS3FileSystemFileHandle,
+  FileSystemRegistry,
+  MemoryFileSystemAdapter,
+  NodeFileSystemAdapter,
+  NodeFileSystemDirectoryHandle,
+  NodeFileSystemFileHandle,
+  getFileSystemRoot
+};

package/src/memory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * In-memory implementation of File System Access API
+ *
+ * Provides a complete filesystem interface using in-memory data structures.
+ * Useful for testing, development, and temporary storage scenarios.
+ */
+import type { FileSystemAdapter, FileSystemConfig } from "./types.js";
+/**
+ * Memory filesystem adapter
+ */
+export declare class MemoryFileSystemAdapter implements FileSystemAdapter {
+    private config;
+    private filesystems;
+    constructor(config?: FileSystemConfig);
+    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    getConfig(): FileSystemConfig;
+    dispose(): Promise<void>;
+}

package/src/memory.js

@@ -0,0 +1,223 @@
+/// <reference types="./memory.d.ts" />
+// src/memory.ts
+var MemoryFileSystemWritableFileStream = class extends WritableStream {
+  constructor(onClose) {
+    super({
+      write: (chunk) => {
+        this.chunks.push(chunk);
+        return Promise.resolve();
+      },
+      close: () => {
+        const totalLength = this.chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const content = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of this.chunks) {
+          content.set(chunk, offset);
+          offset += chunk.length;
+        }
+        this.onClose(content);
+        return Promise.resolve();
+      },
+      abort: () => {
+        this.chunks = [];
+        return Promise.resolve();
+      }
+    });
+    this.onClose = onClose;
+  }
+  chunks = [];
+};
+var MemoryFileSystemFileHandle = class _MemoryFileSystemFileHandle {
+  constructor(file, updateFile) {
+    this.file = file;
+    this.updateFile = updateFile;
+    this.name = file.name;
+  }
+  kind = "file";
+  name;
+  async getFile() {
+    return new File([this.file.content], this.file.name, {
+      lastModified: this.file.lastModified,
+      type: this.file.type
+    });
+  }
+  async createWritable() {
+    return new MemoryFileSystemWritableFileStream((content) => {
+      this.updateFile(content);
+    });
+  }
+  async createSyncAccessHandle() {
+    throw new DOMException(
+      "Synchronous access handles are not supported in memory filesystem",
+      "InvalidStateError"
+    );
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "file")
+      return false;
+    if (!(other instanceof _MemoryFileSystemFileHandle))
+      return false;
+    return this.file === other.file;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+};
+var MemoryFileSystemDirectoryHandle = class _MemoryFileSystemDirectoryHandle {
+  constructor(directory) {
+    this.directory = directory;
+    this.name = directory.name;
+  }
+  kind = "directory";
+  name;
+  async getFileHandle(name, options) {
+    const file = this.directory.files.get(name);
+    if (!file && options?.create) {
+      const newFile = {
+        name,
+        content: new Uint8Array(0),
+        lastModified: Date.now(),
+        type: "application/octet-stream"
+      };
+      this.directory.files.set(name, newFile);
+      return new MemoryFileSystemFileHandle(newFile, (content, type) => {
+        newFile.content = content;
+        newFile.lastModified = Date.now();
+        if (type)
+          newFile.type = type;
+      });
+    } else if (!file) {
+      throw new DOMException("File not found", "NotFoundError");
+    }
+    return new MemoryFileSystemFileHandle(file, (content, type) => {
+      file.content = content;
+      file.lastModified = Date.now();
+      if (type)
+        file.type = type;
+    });
+  }
+  async getDirectoryHandle(name, options) {
+    const dir = this.directory.directories.get(name);
+    if (!dir && options?.create) {
+      const newDir = {
+        name,
+        files: /* @__PURE__ */ new Map(),
+        directories: /* @__PURE__ */ new Map()
+      };
+      this.directory.directories.set(name, newDir);
+      return new _MemoryFileSystemDirectoryHandle(newDir);
+    } else if (!dir) {
+      throw new DOMException("Directory not found", "NotFoundError");
+    }
+    return new _MemoryFileSystemDirectoryHandle(dir);
+  }
+  async removeEntry(name, options) {
+    if (this.directory.files.has(name)) {
+      this.directory.files.delete(name);
+      return;
+    }
+    const dir = this.directory.directories.get(name);
+    if (dir) {
+      if (dir.files.size > 0 || dir.directories.size > 0) {
+        if (!options?.recursive) {
+          throw new DOMException(
+            "Directory is not empty",
+            "InvalidModificationError"
+          );
+        }
+      }
+      this.directory.directories.delete(name);
+      return;
+    }
+    throw new DOMException("Entry not found", "NotFoundError");
+  }
+  async resolve(possibleDescendant) {
+    if (possibleDescendant instanceof MemoryFileSystemFileHandle) {
+      if (this.directory.files.has(possibleDescendant.name)) {
+        return [possibleDescendant.name];
+      }
+    }
+    if (possibleDescendant instanceof _MemoryFileSystemDirectoryHandle) {
+      if (this.directory.directories.has(possibleDescendant.name)) {
+        return [possibleDescendant.name];
+      }
+    }
+    return null;
+  }
+  async *entries() {
+    for (const [name, file] of this.directory.files) {
+      yield [
+        name,
+        new MemoryFileSystemFileHandle(file, (content, type) => {
+          file.content = content;
+          file.lastModified = Date.now();
+          if (type)
+            file.type = type;
+        })
+      ];
+    }
+    for (const [name, dir] of this.directory.directories) {
+      yield [name, new _MemoryFileSystemDirectoryHandle(dir)];
+    }
+  }
+  async *keys() {
+    for (const name of this.directory.files.keys()) {
+      yield name;
+    }
+    for (const name of this.directory.directories.keys()) {
+      yield name;
+    }
+  }
+  async *values() {
+    for (const [, handle] of this.entries()) {
+      yield handle;
+    }
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "directory")
+      return false;
+    if (!(other instanceof _MemoryFileSystemDirectoryHandle))
+      return false;
+    return this.directory === other.directory;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+};
+var MemoryFileSystemAdapter = class {
+  config;
+  filesystems = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = {
+      name: "memory",
+      ...config
+    };
+  }
+  async getFileSystemRoot(name = "default") {
+    if (!this.filesystems.has(name)) {
+      const root2 = {
+        name: "root",
+        files: /* @__PURE__ */ new Map(),
+        directories: /* @__PURE__ */ new Map()
+      };
+      this.filesystems.set(name, root2);
+    }
+    const root = this.filesystems.get(name);
+    return new MemoryFileSystemDirectoryHandle(root);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  async dispose() {
+    this.filesystems.clear();
+  }
+};
+export {
+  MemoryFileSystemAdapter
+};

package/src/node.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Node.js implementation of File System Access API
+ *
+ * Implements FileSystemDirectoryHandle and FileSystemFileHandle using fs/promises
+ * to provide universal File System Access API on Node.js platforms.
+ */
+import type { FileSystemAdapter, FileSystemConfig } from "./types.js";
+/**
+ * Node.js implementation of FileSystemWritableFileStream
+ */
+export declare class NodeFileSystemWritableFileStream extends WritableStream<Uint8Array> {
+    private filePath;
+    constructor(filePath: string);
+    write(data: Uint8Array | string): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Node.js implementation of FileSystemFileHandle
+ */
+export declare class NodeFileSystemFileHandle implements FileSystemFileHandle {
+    private filePath;
+    readonly kind: "file";
+    readonly name: string;
+    constructor(filePath: string);
+    getFile(): Promise<File>;
+    createWritable(): Promise<FileSystemWritableFileStream>;
+    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
+    isSameEntry(other: FileSystemHandle): Promise<boolean>;
+    queryPermission(): Promise<PermissionState>;
+    requestPermission(): Promise<PermissionState>;
+    private getMimeType;
+}
+/**
+ * Node.js implementation of FileSystemDirectoryHandle
+ */
+export declare class NodeFileSystemDirectoryHandle implements FileSystemDirectoryHandle {
+    private dirPath;
+    readonly kind: "directory";
+    readonly name: string;
+    constructor(dirPath: string);
+    getFileHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemFileHandle>;
+    getDirectoryHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemDirectoryHandle>;
+    removeEntry(name: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
+    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
+    keys(): AsyncIterableIterator<string>;
+    values(): AsyncIterableIterator<FileSystemHandle>;
+    isSameEntry(other: FileSystemHandle): Promise<boolean>;
+    queryPermission(): Promise<PermissionState>;
+    requestPermission(): Promise<PermissionState>;
+}
+/**
+ * Node.js filesystem adapter
+ */
+export declare class NodeFileSystemAdapter implements FileSystemAdapter {
+    private config;
+    private rootPath;
+    constructor(config?: FileSystemConfig);
+    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    getConfig(): FileSystemConfig;
+}

package/src/node.js

@@ -0,0 +1,266 @@
+/// <reference types="./node.d.ts" />
+// src/node.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { createWriteStream } from "fs";
+var NodeFileSystemWritableFileStream = class extends WritableStream {
+  constructor(filePath) {
+    const writeStream = createWriteStream(filePath);
+    super({
+      write(chunk) {
+        return new Promise((resolve, reject) => {
+          writeStream.write(chunk, (error) => {
+            if (error)
+              reject(error);
+            else
+              resolve();
+          });
+        });
+      },
+      close() {
+        return new Promise((resolve, reject) => {
+          writeStream.end((error) => {
+            if (error)
+              reject(error);
+            else
+              resolve();
+          });
+        });
+      },
+      abort() {
+        writeStream.destroy();
+        return Promise.resolve();
+      }
+    });
+    this.filePath = filePath;
+  }
+  // File System Access API compatibility methods
+  async write(data) {
+    const writer = this.getWriter();
+    try {
+      if (typeof data === "string") {
+        await writer.write(new TextEncoder().encode(data));
+      } else {
+        await writer.write(data);
+      }
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  async close() {
+    const writer = this.getWriter();
+    try {
+      await writer.close();
+    } finally {
+      writer.releaseLock();
+    }
+  }
+};
+var NodeFileSystemFileHandle = class _NodeFileSystemFileHandle {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.name = path.basename(filePath);
+  }
+  kind = "file";
+  name;
+  async getFile() {
+    try {
+      const stats = await fs.stat(this.filePath);
+      const buffer = await fs.readFile(this.filePath);
+      return new File([buffer], this.name, {
+        lastModified: stats.mtime.getTime(),
+        // Attempt to determine MIME type from extension
+        type: this.getMimeType(this.filePath)
+      });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new DOMException("File not found", "NotFoundError");
+      }
+      throw error;
+    }
+  }
+  async createWritable() {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    return new NodeFileSystemWritableFileStream(this.filePath);
+  }
+  async createSyncAccessHandle() {
+    throw new DOMException(
+      "Synchronous access handles are only available in workers",
+      "InvalidStateError"
+    );
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "file")
+      return false;
+    if (!(other instanceof _NodeFileSystemFileHandle))
+      return false;
+    return this.filePath === other.filePath;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+  getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+      ".txt": "text/plain",
+      ".html": "text/html",
+      ".css": "text/css",
+      ".js": "text/javascript",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".pdf": "application/pdf",
+      ".zip": "application/zip"
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+};
+var NodeFileSystemDirectoryHandle = class _NodeFileSystemDirectoryHandle {
+  constructor(dirPath) {
+    this.dirPath = dirPath;
+    this.name = path.basename(dirPath);
+  }
+  kind = "directory";
+  name;
+  async getFileHandle(name, options) {
+    const filePath = path.join(this.dirPath, name);
+    try {
+      const stats = await fs.stat(filePath);
+      if (!stats.isFile()) {
+        throw new DOMException(
+          "Path exists but is not a file",
+          "TypeMismatchError"
+        );
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (options?.create) {
+          await fs.mkdir(this.dirPath, { recursive: true });
+          await fs.writeFile(filePath, "");
+        } else {
+          throw new DOMException("File not found", "NotFoundError");
+        }
+      } else {
+        throw error;
+      }
+    }
+    return new NodeFileSystemFileHandle(filePath);
+  }
+  async getDirectoryHandle(name, options) {
+    const subDirPath = path.join(this.dirPath, name);
+    try {
+      const stats = await fs.stat(subDirPath);
+      if (!stats.isDirectory()) {
+        throw new DOMException(
+          "Path exists but is not a directory",
+          "TypeMismatchError"
+        );
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (options?.create) {
+          await fs.mkdir(subDirPath, { recursive: true });
+        } else {
+          throw new DOMException("Directory not found", "NotFoundError");
+        }
+      } else {
+        throw error;
+      }
+    }
+    return new _NodeFileSystemDirectoryHandle(subDirPath);
+  }
+  async removeEntry(name, options) {
+    const entryPath = path.join(this.dirPath, name);
+    try {
+      const stats = await fs.stat(entryPath);
+      if (stats.isDirectory()) {
+        await fs.rmdir(entryPath, { recursive: options?.recursive });
+      } else {
+        await fs.unlink(entryPath);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new DOMException("Entry not found", "NotFoundError");
+      }
+      throw error;
+    }
+  }
+  async resolve(_possibleDescendant) {
+    return null;
+  }
+  async *entries() {
+    try {
+      const entries = await fs.readdir(this.dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path.join(this.dirPath, entry.name);
+        if (entry.isDirectory()) {
+          yield [entry.name, new _NodeFileSystemDirectoryHandle(entryPath)];
+        } else if (entry.isFile()) {
+          yield [entry.name, new NodeFileSystemFileHandle(entryPath)];
+        }
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new DOMException("Directory not found", "NotFoundError");
+      }
+      throw error;
+    }
+  }
+  async *keys() {
+    for await (const [name] of this.entries()) {
+      yield name;
+    }
+  }
+  async *values() {
+    for await (const [, handle] of this.entries()) {
+      yield handle;
+    }
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "directory")
+      return false;
+    if (!(other instanceof _NodeFileSystemDirectoryHandle))
+      return false;
+    return this.dirPath === other.dirPath;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+};
+var NodeFileSystemAdapter = class {
+  config;
+  rootPath;
+  constructor(config = {}) {
+    this.config = {
+      name: "node",
+      ...config
+    };
+    this.rootPath = config.rootPath || path.join(process.cwd(), "dist");
+  }
+  async getFileSystemRoot(name = "default") {
+    const bucketPath = path.join(this.rootPath, name);
+    try {
+      await fs.mkdir(bucketPath, { recursive: true });
+    } catch (error) {
+    }
+    return new NodeFileSystemDirectoryHandle(bucketPath);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+};
+export {
+  NodeFileSystemAdapter,
+  NodeFileSystemDirectoryHandle,
+  NodeFileSystemFileHandle,
+  NodeFileSystemWritableFileStream
+};

package/src/registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Filesystem adapter registry
+ * Manages registration and retrieval of filesystem adapters
+ */
+import type { FileSystemAdapter } from "./types.js";
+/**
+ * Global registry of filesystem adapters
+ */
+declare class Registry {
+    private adapters;
+    private defaultAdapter;
+    constructor();
+    /**
+     * Register a filesystem adapter with a name
+     */
+    register(name: string, adapter: FileSystemAdapter): void;
+    /**
+     * Get a filesystem adapter by name
+     */
+    get(name?: string): FileSystemAdapter | null;
+    /**
+     * Set the default filesystem adapter
+     */
+    setDefault(adapter: FileSystemAdapter): void;
+    /**
+     * Get all registered adapter names
+     */
+    getAdapterNames(): string[];
+    /**
+     * Clear all registered adapters
+     */
+    clear(): void;
+}
+/**
+ * Global filesystem registry instance
+ */
+export declare const FileSystemRegistry: Registry;
+/**
+ * Get a file system root handle using the registered adapters
+ * @param name Optional adapter name (uses default if not specified)
+ */
+export declare function getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+export {};

package/src/registry.js

@@ -0,0 +1,63 @@
+/// <reference types="./registry.d.ts" />
+// src/registry.ts
+import { MemoryFileSystemAdapter } from "./memory.js";
+var Registry = class {
+  adapters = /* @__PURE__ */ new Map();
+  defaultAdapter;
+  constructor() {
+    this.defaultAdapter = new MemoryFileSystemAdapter();
+  }
+  /**
+   * Register a filesystem adapter with a name
+   */
+  register(name, adapter) {
+    this.adapters.set(name, adapter);
+    if (!this.defaultAdapter) {
+      this.defaultAdapter = adapter;
+    }
+  }
+  /**
+   * Get a filesystem adapter by name
+   */
+  get(name) {
+    if (!name) {
+      return this.defaultAdapter;
+    }
+    return this.adapters.get(name) || this.defaultAdapter;
+  }
+  /**
+   * Set the default filesystem adapter
+   */
+  setDefault(adapter) {
+    this.defaultAdapter = adapter;
+  }
+  /**
+   * Get all registered adapter names
+   */
+  getAdapterNames() {
+    return Array.from(this.adapters.keys());
+  }
+  /**
+   * Clear all registered adapters
+   */
+  clear() {
+    this.adapters.clear();
+    this.defaultAdapter = null;
+  }
+};
+var FileSystemRegistry = new Registry();
+async function getFileSystemRoot(name) {
+  const adapter = FileSystemRegistry.get(name);
+  if (!adapter) {
+    if (name) {
+      throw new Error(`No filesystem adapter registered with name: ${name}`);
+    } else {
+      throw new Error("No default filesystem adapter registered");
+    }
+  }
+  return await adapter.getFileSystemRoot(name);
+}
+export {
+  FileSystemRegistry,
+  getFileSystemRoot
+};

package/src/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Core filesystem adapter interface and types
+ */
+/**
+ * Configuration for filesystem adapters
+ */
+export interface FileSystemConfig {
+    /** Human readable name for this filesystem */
+    name?: string;
+    /** Platform-specific configuration */
+    [key: string]: any;
+}
+/**
+ * Core interface that all filesystem adapters must implement
+ * Provides File System Access API compatibility across all platforms
+ */
+export interface FileSystemAdapter {
+    /**
+     * Get a root directory handle for the filesystem
+     * @param name Optional filesystem name/bucket identifier
+     */
+    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    /**
+     * Get configuration for this adapter
+     */
+    getConfig(): FileSystemConfig;
+    /**
+     * Cleanup resources when adapter is no longer needed
+     */
+    dispose?(): Promise<void>;
+}

package/src/types.js

@@ -0,0 +1 @@
+/// <reference types="./types.d.ts" />