@aprovan/patchwork-compiler 0.1.0 → 0.1.2-dev.6bd527d

package/dist/index.js

@@ -182,7 +182,7 @@ async function loadLocalImage(name) {
   try {
     const { createRequire } = await import("module");
     const { readFile } = await import("fs/promises");
-    const { dirname: dirname2, join } = await import("path");
+    const { dirname: dirname3, join: join2 } = await import("path");
     const require2 = createRequire(import.meta.url);
     let packageJsonPath;
     try {
@@ -195,10 +195,10 @@ async function loadLocalImage(name) {
     const config = safeParseImageConfig(packageJson.patchwork) || DEFAULT_IMAGE_CONFIG;
     let setup;
     let mount;
-    const packageDir = dirname2(packageJsonPath);
+    const packageDir = dirname3(packageJsonPath);
     if (packageJson.main) {
       try {
-        const mainPath = join(packageDir, packageJson.main);
+        const mainPath = join2(packageDir, packageJson.main);
         const imageModule = await import(
           /* webpackIgnore: true */
           /* @vite-ignore */
@@ -1627,70 +1627,634 @@ var PatchworkCompiler = class {
   }
 };
 
-// src/vfs/store.ts
-var VFSStore = class {
-  constructor(backend, root = "") {
-    this.backend = backend;
-    this.root = root;
+// src/vfs/core/utils.ts
+function createFileStats(size, mtime, isDir = false) {
+  return {
+    size,
+    mtime,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+function createDirEntry(name, isDir) {
+  return {
+    name,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+function normalizePath2(path) {
+  return path.replace(/\/+/g, "/").replace(/^\/|\/$/g, "");
+}
+function dirname2(path) {
+  const normalized = normalizePath2(path);
+  const lastSlash = normalized.lastIndexOf("/");
+  return lastSlash === -1 ? "" : normalized.slice(0, lastSlash);
+}
+function join(...parts) {
+  return normalizePath2(parts.filter(Boolean).join("/"));
+}
+
+// src/vfs/backends/memory.ts
+var MemoryBackend = class {
+  files = /* @__PURE__ */ new Map();
+  dirs = /* @__PURE__ */ new Set([""]);
+  watchers = /* @__PURE__ */ new Map();
+  async readFile(path) {
+    const entry = this.files.get(normalizePath2(path));
+    if (!entry) throw new Error(`ENOENT: ${path}`);
+    return entry.content;
+  }
+  async writeFile(path, content) {
+    const normalized = normalizePath2(path);
+    const dir = dirname2(normalized);
+    if (dir && !this.dirs.has(dir)) {
+      throw new Error(`ENOENT: ${dir}`);
+    }
+    const isNew = !this.files.has(normalized);
+    this.files.set(normalized, { content, mtime: /* @__PURE__ */ new Date() });
+    this.emit(isNew ? "create" : "update", normalized);
+  }
+  async unlink(path) {
+    const normalized = normalizePath2(path);
+    if (!this.files.delete(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    this.emit("delete", normalized);
   }
-  key(path) {
-    return this.root ? `${this.root}/${path}` : path;
+  async stat(path) {
+    const normalized = normalizePath2(path);
+    const entry = this.files.get(normalized);
+    if (entry) {
+      return createFileStats(entry.content.length, entry.mtime, false);
+    }
+    if (this.dirs.has(normalized)) {
+      return createFileStats(0, /* @__PURE__ */ new Date(), true);
+    }
+    throw new Error(`ENOENT: ${path}`);
+  }
+  async mkdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (this.dirs.has(normalized)) return;
+    const parent = dirname2(normalized);
+    if (parent && !this.dirs.has(parent)) {
+      if (options?.recursive) {
+        await this.mkdir(parent, options);
+      } else {
+        throw new Error(`ENOENT: ${parent}`);
+      }
+    }
+    this.dirs.add(normalized);
+  }
+  async readdir(path) {
+    const normalized = normalizePath2(path);
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = normalized ? `${normalized}/` : "";
+    const entries = /* @__PURE__ */ new Map();
+    for (const filePath of this.files.keys()) {
+      if (filePath.startsWith(prefix)) {
+        const rest = filePath.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name) entries.set(name, false);
+      }
+    }
+    for (const dirPath of this.dirs) {
+      if (dirPath.startsWith(prefix) && dirPath !== normalized) {
+        const rest = dirPath.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name) entries.set(name, true);
+      }
+    }
+    return Array.from(entries).map(
+      ([name, isDir]) => createDirEntry(name, isDir)
+    );
+  }
+  async rmdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (!this.dirs.has(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = `${normalized}/`;
+    const hasChildren = [...this.files.keys()].some((p) => p.startsWith(prefix)) || [...this.dirs].some((d) => d.startsWith(prefix));
+    if (hasChildren && !options?.recursive) {
+      throw new Error(`ENOTEMPTY: ${path}`);
+    }
+    if (options?.recursive) {
+      for (const filePath of this.files.keys()) {
+        if (filePath.startsWith(prefix)) {
+          this.files.delete(filePath);
+          this.emit("delete", filePath);
+        }
+      }
+      for (const dirPath of this.dirs) {
+        if (dirPath.startsWith(prefix)) {
+          this.dirs.delete(dirPath);
+        }
+      }
+    }
+    this.dirs.delete(normalized);
+  }
+  async exists(path) {
+    const normalized = normalizePath2(path);
+    return this.files.has(normalized) || this.dirs.has(normalized);
+  }
+  watch(path, callback) {
+    const normalized = normalizePath2(path);
+    let callbacks = this.watchers.get(normalized);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      this.watchers.set(normalized, callbacks);
+    }
+    callbacks.add(callback);
+    return () => callbacks.delete(callback);
+  }
+  emit(event, path) {
+    let current = path;
+    while (true) {
+      const callbacks = this.watchers.get(current);
+      if (callbacks) {
+        for (const cb of callbacks) cb(event, path);
+      }
+      if (!current) break;
+      current = dirname2(current);
+    }
   }
-  async getFile(path) {
-    const content = await this.backend.get(this.key(path));
-    if (!content) return null;
-    return { path, content };
+};
+
+// src/vfs/core/virtual-fs.ts
+var VirtualFS = class {
+  changes = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  backend;
+  constructor(backend) {
+    this.backend = backend ?? new MemoryBackend();
+  }
+  async readFile(path, encoding) {
+    return this.backend.readFile(path, encoding);
+  }
+  async writeFile(path, content) {
+    const existed = await this.backend.exists(path);
+    await this.backend.writeFile(path, content);
+    this.recordChange(path, existed ? "update" : "create");
+  }
+  async applyRemoteFile(path, content) {
+    await this.backend.writeFile(path, content);
+  }
+  async applyRemoteDelete(path) {
+    try {
+      if (await this.backend.exists(path)) {
+        await this.backend.unlink(path);
+      }
+    } catch {
+      return;
+    }
   }
-  async putFile(file) {
-    await this.backend.put(this.key(file.path), file.content);
+  async unlink(path) {
+    await this.backend.unlink(path);
+    this.recordChange(path, "delete");
   }
-  async deleteFile(path) {
-    await this.backend.delete(this.key(path));
+  async stat(path) {
+    return this.backend.stat(path);
   }
-  async listFiles(prefix) {
-    const fullPrefix = prefix ? this.key(prefix) : this.root;
-    const paths = await this.backend.list(fullPrefix);
-    return paths.map((p) => this.root ? p.slice(this.root.length + 1) : p);
+  async mkdir(path, options) {
+    return this.backend.mkdir(path, options);
   }
-  async loadProject(id) {
-    const paths = await this.listFiles(id);
-    if (paths.length === 0) return null;
-    const files = /* @__PURE__ */ new Map();
-    await Promise.all(
-      paths.map(async (path) => {
-        const file = await this.getFile(path);
-        if (file) files.set(path.slice(id.length + 1), file);
-      })
-    );
-    return { id, entry: resolveEntry(files), files };
+  async readdir(path) {
+    return this.backend.readdir(path);
   }
-  async saveProject(project) {
-    await Promise.all(
-      Array.from(project.files.values()).map(
-        (file) => this.putFile({ ...file, path: `${project.id}/${file.path}` })
-      )
-    );
+  async rmdir(path, options) {
+    return this.backend.rmdir(path, options);
+  }
+  async exists(path) {
+    return this.backend.exists(path);
+  }
+  watch(path, callback) {
+    if (this.backend.watch) {
+      return this.backend.watch(path, callback);
+    }
+    return () => {
+    };
+  }
+  /**
+   * Get all pending changes since last sync
+   */
+  getChanges() {
+    return Array.from(this.changes.values());
+  }
+  /**
+   * Clear change tracking (after successful sync)
+   */
+  clearChanges() {
+    this.changes.clear();
+  }
+  /**
+   * Mark specific paths as synced
+   */
+  markSynced(paths) {
+    for (const path of paths) {
+      this.changes.delete(path);
+    }
+  }
+  /**
+   * Subscribe to change events
+   */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  recordChange(path, type) {
+    const record = { path, type, mtime: /* @__PURE__ */ new Date() };
+    this.changes.set(path, record);
+    for (const listener of this.listeners) {
+      listener(record);
+    }
+  }
+};
+
+// src/vfs/sync/differ.ts
+function hashContent2(content) {
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i += 1) {
+    hash ^= content.charCodeAt(i);
+    hash = hash + (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+async function readChecksum(provider, path) {
+  try {
+    const content = await provider.readFile(path);
+    return hashContent2(content);
+  } catch {
+    return void 0;
+  }
+}
+async function readChecksums(local, localPath, remote, remotePath) {
+  const [localChecksum, remoteChecksum] = await Promise.all([
+    readChecksum(local, localPath),
+    readChecksum(remote, remotePath)
+  ]);
+  return { local: localChecksum, remote: remoteChecksum };
+}
+
+// src/vfs/sync/resolver.ts
+function resolveConflict(input) {
+  if (input.remoteMtime <= input.changeMtime) return null;
+  if (input.localChecksum && input.remoteChecksum && input.localChecksum === input.remoteChecksum) {
+    return null;
+  }
+  const conflict = {
+    path: input.path,
+    localMtime: input.changeMtime,
+    remoteMtime: input.remoteMtime
+  };
+  switch (input.strategy) {
+    case "local-wins":
+      conflict.resolved = "local";
+      break;
+    case "remote-wins":
+      conflict.resolved = "remote";
+      break;
+    case "newest-wins":
+      conflict.resolved = input.remoteMtime > input.changeMtime ? "remote" : "local";
+      break;
+    case "manual":
+      break;
+  }
+  return conflict;
+}
+
+// src/vfs/sync/engine.ts
+var SyncEngineImpl = class {
+  constructor(local, remote, config = {}) {
+    this.local = local;
+    this.remote = remote;
+    this.conflictStrategy = config.conflictStrategy ?? "local-wins";
+    this.basePath = config.basePath ?? "";
+    this.startRemoteWatch();
+  }
+  status = "idle";
+  intervalId;
+  listeners = /* @__PURE__ */ new Map();
+  conflictStrategy;
+  basePath;
+  async sync() {
+    if (this.status === "syncing") {
+      return { pushed: 0, pulled: 0, conflicts: [] };
+    }
+    this.setStatus("syncing");
+    const result = { pushed: 0, pulled: 0, conflicts: [] };
+    try {
+      const localChanges = this.local.getChanges();
+      const localChangeMap = new Map(
+        localChanges.map((change) => [change.path, change])
+      );
+      const syncedPaths = [];
+      const remoteFiles = await this.listFiles(this.remote, this.basePath);
+      const localFiles = await this.listFiles(this.local, "");
+      const remoteLocalPaths = new Set(
+        remoteFiles.map((path) => this.localPath(path))
+      );
+      for (const remotePath of remoteFiles) {
+        const localPath = this.localPath(remotePath);
+        const localChange = localChangeMap.get(localPath);
+        if (localChange) {
+          const conflict = await this.checkConflict(localChange, remotePath);
+          if (conflict) {
+            result.conflicts.push(conflict);
+            this.emit("conflict", conflict);
+            if (conflict.resolved === "remote") {
+              if (await this.pullRemoteFile(localPath, remotePath)) {
+                result.pulled++;
+                this.emit("change", {
+                  path: localPath,
+                  type: "update",
+                  mtime: /* @__PURE__ */ new Date()
+                });
+              }
+              syncedPaths.push(localPath);
+            }
+          }
+          continue;
+        }
+        if (await this.pullRemoteFile(localPath, remotePath)) {
+          result.pulled++;
+          this.emit("change", {
+            path: localPath,
+            type: "update",
+            mtime: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      for (const localPath of localFiles) {
+        if (remoteLocalPaths.has(localPath)) continue;
+        if (localChangeMap.has(localPath)) continue;
+        await this.local.applyRemoteDelete(localPath);
+        result.pulled++;
+        this.emit("change", {
+          path: localPath,
+          type: "delete",
+          mtime: /* @__PURE__ */ new Date()
+        });
+      }
+      for (const change of localChanges) {
+        if (syncedPaths.includes(change.path)) continue;
+        const remotePath = this.remotePath(change.path);
+        try {
+          const conflict = await this.checkConflict(change, remotePath);
+          if (conflict) {
+            result.conflicts.push(conflict);
+            this.emit("conflict", conflict);
+            if (conflict.resolved === "remote") {
+              if (await this.pullRemoteFile(change.path, remotePath)) {
+                result.pulled++;
+                this.emit("change", {
+                  path: change.path,
+                  type: "update",
+                  mtime: /* @__PURE__ */ new Date()
+                });
+              }
+              syncedPaths.push(change.path);
+            }
+            if (conflict.resolved !== "local") continue;
+          }
+          if (change.type === "delete") {
+            if (await this.remote.exists(remotePath)) {
+              await this.remote.unlink(remotePath);
+            }
+            result.pushed++;
+            syncedPaths.push(change.path);
+            this.emit("change", change);
+            continue;
+          }
+          const content = await this.local.readFile(change.path);
+          await this.remote.writeFile(remotePath, content);
+          result.pushed++;
+          syncedPaths.push(change.path);
+          this.emit("change", change);
+        } catch (err) {
+          this.emit(
+            "error",
+            err instanceof Error ? err : new Error(String(err))
+          );
+        }
+      }
+      if (syncedPaths.length > 0) {
+        this.local.markSynced(syncedPaths);
+      }
+      this.setStatus("idle");
+    } catch (err) {
+      this.setStatus("error");
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+    return result;
+  }
+  startAutoSync(intervalMs) {
+    this.stopAutoSync();
+    this.intervalId = setInterval(() => this.sync(), intervalMs);
+  }
+  stopAutoSync() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+  }
+  on(event, callback) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(callback);
+    return () => set.delete(callback);
+  }
+  emit(event, data) {
+    const set = this.listeners.get(event);
+    if (set) {
+      for (const cb of set) cb(data);
+    }
+  }
+  setStatus(status) {
+    this.status = status;
+    this.emit("status", status);
+  }
+  remotePath(localPath) {
+    return this.basePath ? join(this.basePath, localPath) : localPath;
+  }
+  localPath(remotePath) {
+    if (!this.basePath) return normalizePath2(remotePath);
+    const normalized = normalizePath2(remotePath);
+    const base = normalizePath2(this.basePath);
+    if (normalized === base) return "";
+    if (normalized.startsWith(`${base}/`)) {
+      return normalized.slice(base.length + 1);
+    }
+    return normalized;
+  }
+  async listFiles(provider, basePath) {
+    const normalized = normalizePath2(basePath);
+    let entries = [];
+    try {
+      entries = await provider.readdir(normalized);
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+      const entryPath = normalized ? `${normalized}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        results.push(...await this.listFiles(provider, entryPath));
+      } else {
+        results.push(entryPath);
+      }
+    }
+    return results;
+  }
+  async pullRemoteFile(localPath, remotePath) {
+    let localContent = null;
+    try {
+      if (await this.local.exists(localPath)) {
+        localContent = await this.local.readFile(localPath);
+      }
+    } catch {
+      localContent = null;
+    }
+    const remoteContent = await this.remote.readFile(remotePath);
+    if (localContent === remoteContent) return false;
+    await this.local.applyRemoteFile(localPath, remoteContent);
+    return true;
+  }
+  startRemoteWatch() {
+    if (!this.remote.watch) return;
+    this.remote.watch(this.basePath, (event, path) => {
+      void this.handleRemoteEvent(event, path);
+    });
+  }
+  async handleRemoteEvent(event, remotePath) {
+    const localPath = this.localPath(remotePath);
+    const localChange = this.local.getChanges().find((change) => change.path === localPath);
+    if (localChange) {
+      const conflict = await this.checkRemoteEventConflict(
+        localChange,
+        remotePath,
+        event
+      );
+      if (conflict) {
+        this.emit("conflict", conflict);
+        if (conflict.resolved === "remote") {
+          await this.applyRemoteEvent(event, localPath, remotePath);
+          this.local.markSynced([localPath]);
+          this.emit("change", {
+            path: localPath,
+            type: event,
+            mtime: /* @__PURE__ */ new Date()
+          });
+        }
+        return;
+      }
+      return;
+    }
+    try {
+      await this.applyRemoteEvent(event, localPath, remotePath);
+      this.emit("change", {
+        path: localPath,
+        type: event,
+        mtime: /* @__PURE__ */ new Date()
+      });
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  async checkConflict(change, remotePath) {
+    try {
+      const remoteStat = await this.remote.stat(remotePath);
+      if (remoteStat.mtime <= change.mtime) return null;
+      const checksums = await readChecksums(
+        this.local,
+        change.path,
+        this.remote,
+        remotePath
+      );
+      return resolveConflict({
+        path: change.path,
+        changeMtime: change.mtime,
+        remoteMtime: remoteStat.mtime,
+        localChecksum: checksums.local,
+        remoteChecksum: checksums.remote,
+        strategy: this.conflictStrategy
+      });
+    } catch {
+      return null;
+    }
+  }
+  async checkRemoteEventConflict(change, remotePath, event) {
+    if (event === "delete") {
+      if (change.type === "delete") return null;
+      return resolveConflict({
+        path: change.path,
+        changeMtime: change.mtime,
+        remoteMtime: /* @__PURE__ */ new Date(),
+        strategy: this.conflictStrategy
+      });
+    }
+    try {
+      const remoteStat = await this.remote.stat(remotePath);
+      if (remoteStat.mtime <= change.mtime) return null;
+      const checksums = await readChecksums(
+        this.local,
+        change.path,
+        this.remote,
+        remotePath
+      );
+      return resolveConflict({
+        path: change.path,
+        changeMtime: change.mtime,
+        remoteMtime: remoteStat.mtime,
+        localChecksum: checksums.local,
+        remoteChecksum: checksums.remote,
+        strategy: this.conflictStrategy
+      });
+    } catch {
+      return null;
+    }
+  }
+  async applyRemoteEvent(event, localPath, remotePath) {
+    if (event === "delete") {
+      await this.local.applyRemoteDelete(localPath);
+      return;
+    }
+    const content = await this.remote.readFile(remotePath);
+    await this.local.applyRemoteFile(localPath, content);
   }
 };
 
 // src/vfs/backends/indexeddb.ts
 var DB_NAME = "patchwork-vfs";
-var STORE_NAME = "files";
+var DB_VERSION = 2;
+var FILES_STORE = "files";
+var DIRS_STORE = "dirs";
 function openDB() {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, 1);
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
     request.onerror = () => reject(request.error);
     request.onsuccess = () => resolve(request.result);
-    request.onupgradeneeded = () => {
-      request.result.createObjectStore(STORE_NAME);
+    request.onupgradeneeded = (event) => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(FILES_STORE)) {
+        db.createObjectStore(FILES_STORE);
+      }
+      if (!db.objectStoreNames.contains(DIRS_STORE)) {
+        db.createObjectStore(DIRS_STORE);
+      }
     };
   });
 }
-function withStore(mode, fn) {
+function withStore(storeName, mode, fn) {
   return openDB().then(
     (db) => new Promise((resolve, reject) => {
-      const tx = db.transaction(STORE_NAME, mode);
-      const store = tx.objectStore(STORE_NAME);
+      const tx = db.transaction(storeName, mode);
+      const store = tx.objectStore(storeName);
       const request = fn(store);
       request.onerror = () => reject(request.error);
       request.onsuccess = () => resolve(request.result);
@@ -1702,107 +2266,419 @@ var IndexedDBBackend = class {
     this.prefix = prefix;
   }
   key(path) {
-    return `${this.prefix}:${path}`;
+    return `${this.prefix}:${normalizePath2(path)}`;
   }
-  async get(path) {
-    const result = await withStore(
+  async readFile(path) {
+    const record = await withStore(
+      FILES_STORE,
       "readonly",
       (store) => store.get(this.key(path))
     );
-    return result ?? null;
+    if (!record) throw new Error(`ENOENT: ${path}`);
+    return record.content;
   }
-  async put(path, content) {
-    await withStore("readwrite", (store) => store.put(content, this.key(path)));
+  async writeFile(path, content) {
+    const dir = dirname2(normalizePath2(path));
+    if (dir && !await this.dirExists(dir)) {
+      throw new Error(`ENOENT: ${dir}`);
+    }
+    const record = { content, mtime: Date.now() };
+    await withStore(
+      FILES_STORE,
+      "readwrite",
+      (store) => store.put(record, this.key(path))
+    );
+  }
+  async unlink(path) {
+    await withStore(
+      FILES_STORE,
+      "readwrite",
+      (store) => store.delete(this.key(path))
+    );
+  }
+  async stat(path) {
+    const normalized = normalizePath2(path);
+    const record = await withStore(
+      FILES_STORE,
+      "readonly",
+      (store) => store.get(this.key(normalized))
+    );
+    if (record) {
+      return createFileStats(
+        record.content.length,
+        new Date(record.mtime),
+        false
+      );
+    }
+    if (await this.dirExists(normalized)) {
+      return createFileStats(0, /* @__PURE__ */ new Date(), true);
+    }
+    throw new Error(`ENOENT: ${path}`);
+  }
+  async mkdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (await this.dirExists(normalized)) return;
+    const parent = dirname2(normalized);
+    if (parent && !await this.dirExists(parent)) {
+      if (options?.recursive) {
+        await this.mkdir(parent, options);
+      } else {
+        throw new Error(`ENOENT: ${parent}`);
+      }
+    }
+    await withStore(
+      DIRS_STORE,
+      "readwrite",
+      (store) => store.put(Date.now(), this.key(normalized))
+    );
   }
-  async delete(path) {
-    await withStore("readwrite", (store) => store.delete(this.key(path)));
+  async readdir(path) {
+    const normalized = normalizePath2(path);
+    if (normalized && !await this.dirExists(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = normalized ? `${this.key(normalized)}/` : `${this.prefix}:`;
+    const entries = /* @__PURE__ */ new Map();
+    const fileKeys = await withStore(
+      FILES_STORE,
+      "readonly",
+      (store) => store.getAllKeys()
+    );
+    for (const key of fileKeys) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name && !rest.includes("/")) entries.set(name, false);
+      }
+    }
+    const dirKeys = await withStore(
+      DIRS_STORE,
+      "readonly",
+      (store) => store.getAllKeys()
+    );
+    for (const key of dirKeys) {
+      if (key.startsWith(prefix)) {
+        const rest = key.slice(prefix.length);
+        const name = rest.split("/")[0];
+        if (name && !rest.includes("/")) entries.set(name, true);
+      }
+    }
+    return Array.from(entries).map(
+      ([name, isDir]) => createDirEntry(name, isDir)
+    );
   }
-  async list(prefix) {
-    const keyPrefix = prefix ? this.key(prefix) : this.key("");
-    const allKeys = await withStore("readonly", (store) => store.getAllKeys());
-    return allKeys.filter((k) => k.startsWith(keyPrefix)).map((k) => k.slice(this.prefix.length + 1));
+  async rmdir(path, options) {
+    const normalized = normalizePath2(path);
+    if (!await this.dirExists(normalized)) {
+      throw new Error(`ENOENT: ${path}`);
+    }
+    const prefix = `${this.key(normalized)}/`;
+    if (options?.recursive) {
+      const fileKeys = await withStore(
+        FILES_STORE,
+        "readonly",
+        (store) => store.getAllKeys()
+      );
+      for (const key of fileKeys) {
+        if (key.startsWith(prefix)) {
+          await withStore(
+            FILES_STORE,
+            "readwrite",
+            (store) => store.delete(key)
+          );
+        }
+      }
+      const dirKeys = await withStore(
+        DIRS_STORE,
+        "readonly",
+        (store) => store.getAllKeys()
+      );
+      for (const key of dirKeys) {
+        if (key.startsWith(prefix)) {
+          await withStore(
+            DIRS_STORE,
+            "readwrite",
+            (store) => store.delete(key)
+          );
+        }
+      }
+    }
+    await withStore(
+      DIRS_STORE,
+      "readwrite",
+      (store) => store.delete(this.key(normalized))
+    );
   }
   async exists(path) {
-    return await this.get(path) !== null;
+    const normalized = normalizePath2(path);
+    const record = await withStore(
+      FILES_STORE,
+      "readonly",
+      (store) => store.get(this.key(normalized))
+    );
+    if (record) return true;
+    return this.dirExists(normalized);
+  }
+  async dirExists(path) {
+    if (!path) return true;
+    const result = await withStore(
+      DIRS_STORE,
+      "readonly",
+      (store) => store.get(this.key(path))
+    );
+    return result !== void 0;
   }
 };
 
-// src/vfs/backends/local-fs.ts
-var LocalFSBackend = class {
+// src/vfs/backends/http.ts
+var HttpBackend = class {
   constructor(config) {
     this.config = config;
   }
-  async get(path) {
-    const res = await fetch(`${this.config.baseUrl}/${path}`);
-    if (!res.ok) return null;
+  async readFile(path) {
+    const res = await fetch(this.url(path));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
     return res.text();
   }
-  async put(path, content) {
-    await fetch(`${this.config.baseUrl}/${path}`, {
+  async writeFile(path, content) {
+    const res = await fetch(this.url(path), {
       method: "PUT",
-      body: content
+      body: content,
+      headers: { "Content-Type": "text/plain" }
     });
-  }
-  async delete(path) {
-    await fetch(`${this.config.baseUrl}/${path}`, { method: "DELETE" });
-  }
-  async list(prefix) {
-    const url = prefix ? `${this.config.baseUrl}?prefix=${encodeURIComponent(prefix)}` : this.config.baseUrl;
-    const res = await fetch(url);
-    return res.json();
+    if (!res.ok) throw new Error(`Failed to write: ${path}`);
+  }
+  async unlink(path) {
+    const res = await fetch(this.url(path), { method: "DELETE" });
+    if (!res.ok) throw new Error(`Failed to delete: ${path}`);
+  }
+  async stat(path) {
+    const res = await fetch(this.url(path, { stat: "true" }));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    const data = await res.json();
+    return createFileStats(data.size, new Date(data.mtime), data.isDirectory);
+  }
+  async mkdir(path, options) {
+    const params = { mkdir: "true" };
+    if (options?.recursive) params.recursive = "true";
+    const res = await fetch(this.url(path, params), { method: "POST" });
+    if (!res.ok) throw new Error(`Failed to mkdir: ${path}`);
+  }
+  async readdir(path) {
+    const res = await fetch(this.url(path, { readdir: "true" }));
+    if (!res.ok) throw new Error(`ENOENT: ${path}`);
+    const entries = await res.json();
+    return entries.map((e) => createDirEntry(e.name, e.isDirectory));
+  }
+  async rmdir(path, options) {
+    const params = {};
+    if (options?.recursive) params.recursive = "true";
+    const res = await fetch(this.url(path, params), { method: "DELETE" });
+    if (!res.ok) throw new Error(`Failed to rmdir: ${path}`);
   }
   async exists(path) {
-    const res = await fetch(`${this.config.baseUrl}/${path}`, {
-      method: "HEAD"
-    });
+    const res = await fetch(this.url(path), { method: "HEAD" });
     return res.ok;
   }
+  watch(path, callback) {
+    const controller = new AbortController();
+    this.startWatch(path, callback, controller.signal);
+    return () => controller.abort();
+  }
+  async startWatch(path, callback, signal) {
+    try {
+      const res = await fetch(this.url("", { watch: path }), { signal });
+      if (!res.ok) return;
+      const reader = res.body?.getReader();
+      if (!reader) return;
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event = JSON.parse(line.slice(6));
+              callback(event.type, event.path);
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  url(path, params) {
+    const baseUrl = this.config.baseUrl.replace(/\/+$/, "");
+    const cleanPath = path.replace(/^\/+/, "");
+    const base = cleanPath ? `${baseUrl}/${cleanPath}` : baseUrl;
+    if (!params) return base;
+    const query = new URLSearchParams(params).toString();
+    return `${base}?${query}`;
+  }
 };
 
-// src/vfs/backends/s3.ts
-var S3Backend = class {
-  constructor(config) {
-    this.config = config;
+// src/vfs/store.ts
+var VFSStore = class {
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.root = options.root ?? "";
+    if (options.sync) {
+      this.local = new VirtualFS();
+      this.syncEngine = new SyncEngineImpl(this.local, this.provider, {
+        conflictStrategy: options.conflictStrategy,
+        basePath: this.root
+      });
+      if (options.autoSyncIntervalMs) {
+        this.syncEngine.startAutoSync(options.autoSyncIntervalMs);
+      }
+    }
   }
-  get baseUrl() {
-    return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com`;
+  local;
+  syncEngine;
+  root;
+  async readFile(path, encoding) {
+    if (this.local) {
+      try {
+        return await this.local.readFile(path, encoding);
+      } catch {
+        const content = await this.provider.readFile(
+          this.remotePath(path),
+          encoding
+        );
+        await this.local.applyRemoteFile(path, content);
+        return content;
+      }
+    }
+    return this.provider.readFile(this.remotePath(path), encoding);
   }
-  key(path) {
-    return this.config.prefix ? `${this.config.prefix}/${path}` : path;
+  async writeFile(path, content) {
+    if (this.local) {
+      await this.local.writeFile(path, content);
+      return;
+    }
+    await this.provider.writeFile(this.remotePath(path), content);
   }
-  async get(path) {
-    const res = await fetch(`${this.baseUrl}/${this.key(path)}`);
-    if (!res.ok) return null;
-    return res.text();
+  async unlink(path) {
+    if (this.local) {
+      await this.local.unlink(path);
+      return;
+    }
+    await this.provider.unlink(this.remotePath(path));
   }
-  async put(path, content) {
-    await fetch(`${this.baseUrl}/${this.key(path)}`, {
-      method: "PUT",
-      body: content,
-      headers: { "Content-Type": "text/plain" }
-    });
+  async stat(path) {
+    if (this.local) {
+      try {
+        return await this.local.stat(path);
+      } catch {
+        return this.provider.stat(this.remotePath(path));
+      }
+    }
+    return this.provider.stat(this.remotePath(path));
   }
-  async delete(path) {
-    await fetch(`${this.baseUrl}/${this.key(path)}`, { method: "DELETE" });
+  async mkdir(path, options) {
+    if (this.local) {
+      await this.local.mkdir(path, options);
+    }
+    await this.provider.mkdir(this.remotePath(path), options);
   }
-  async list(prefix) {
-    const listPrefix = prefix ? this.key(prefix) : this.config.prefix || "";
-    const res = await fetch(
-      `${this.baseUrl}?list-type=2&prefix=${encodeURIComponent(listPrefix)}`
-    );
-    const xml = await res.text();
-    return this.parseListResponse(xml);
+  async readdir(path) {
+    if (this.local) {
+      try {
+        return await this.local.readdir(path);
+      } catch {
+        return this.provider.readdir(this.remotePath(path));
+      }
+    }
+    return this.provider.readdir(this.remotePath(path));
+  }
+  async rmdir(path, options) {
+    if (this.local) {
+      await this.local.rmdir(path, options);
+    }
+    await this.provider.rmdir(this.remotePath(path), options);
   }
   async exists(path) {
-    const res = await fetch(`${this.baseUrl}/${this.key(path)}`, {
-      method: "HEAD"
-    });
-    return res.ok;
+    if (this.local) {
+      if (await this.local.exists(path)) return true;
+      return this.provider.exists(this.remotePath(path));
+    }
+    return this.provider.exists(this.remotePath(path));
+  }
+  async listFiles(prefix = "") {
+    return this.walkFiles(prefix);
+  }
+  async loadProject(id) {
+    const paths = await this.listFiles(id);
+    if (paths.length === 0) return null;
+    const files = /* @__PURE__ */ new Map();
+    await Promise.all(
+      paths.map(async (path) => {
+        const content = await this.provider.readFile(this.remotePath(path));
+        const relative = path.slice(id.length + 1);
+        files.set(relative, { path: relative, content });
+        if (this.local) {
+          await this.local.applyRemoteFile(path, content);
+        }
+      })
+    );
+    return { id, entry: resolveEntry(files), files };
+  }
+  async saveProject(project) {
+    if (this.local) {
+      await Promise.all(
+        Array.from(project.files.values()).map(
+          (file) => this.local.writeFile(`${project.id}/${file.path}`, file.content)
+        )
+      );
+      await this.sync();
+      return;
+    }
+    await Promise.all(
+      Array.from(project.files.values()).map(
+        (file) => this.provider.writeFile(
+          this.remotePath(`${project.id}/${file.path}`),
+          file.content
+        )
+      )
+    );
+  }
+  async sync() {
+    if (!this.syncEngine) {
+      return { pushed: 0, pulled: 0, conflicts: [] };
+    }
+    return this.syncEngine.sync();
   }
-  parseListResponse(xml) {
-    const matches = xml.matchAll(/<Key>([^<]+)<\/Key>/g);
-    const prefixLen = this.config.prefix ? this.config.prefix.length + 1 : 0;
-    return Array.from(matches, (m) => (m[1] ?? "").slice(prefixLen));
+  on(event, callback) {
+    if (!this.syncEngine) return () => {
+    };
+    return this.syncEngine.on(event, callback);
+  }
+  remotePath(path) {
+    return this.root ? join(this.root, path) : path;
+  }
+  async walkFiles(prefix) {
+    const results = [];
+    const normalized = prefix ? prefix.replace(/^\/+/g, "") : "";
+    let entries = [];
+    try {
+      entries = await this.provider.readdir(this.remotePath(normalized));
+    } catch {
+      return results;
+    }
+    for (const entry of entries) {
+      const entryPath = normalized ? `${normalized}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        results.push(...await this.walkFiles(entryPath));
+      } else {
+        results.push(entryPath);
+      }
+    }
+    return results;
   }
 };
 export {
@@ -1811,17 +2687,16 @@ export {
   DEFAULT_IMAGE_CONFIG,
   DEV_SANDBOX,
   EsbuildConfigSchema,
+  HttpBackend,
   ImageConfigSchema,
   ImageRegistry,
   IndexedDBBackend,
   InputSpecSchema,
-  LocalFSBackend,
   ManifestSchema,
   MountModeSchema,
   MountOptionsSchema,
   ParentBridge,
   PlatformSchema,
-  S3Backend,
   VFSStore,
   cdnTransformPlugin,
   createCompiler,