@struktoai/mirage-node 0.0.3-alpha.0 → 0.0.3

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   GmailResource
-} from "./chunk-HEHERHQ5.js";
+} from "./chunk-MPCCRRE6.js";
 import {
   EMAIL_COMMANDS,
   EMAIL_OPS,
@@ -8,7 +8,7 @@ import {
   EMAIL_WRITE_PROMPT,
   EmailAccessor,
   EmailResource
-} from "./chunk-DTAY7LPC.js";
+} from "./chunk-S5OVP467.js";
 import {
   buildEmailConfig,
   normalizeEmailConfig,
@@ -16,24 +16,24 @@ import {
 } from "./chunk-B2ZOKNN4.js";
 import {
   GSlidesResource
-} from "./chunk-E7RW3SBV.js";
+} from "./chunk-A7IVFIOP.js";
 import {
   GDriveResource
-} from "./chunk-TRTUHCS4.js";
+} from "./chunk-QCZ2XUKH.js";
 import {
   normalizeGDriveConfig,
   redactGDriveConfig
 } from "./chunk-DP2PP5V2.js";
 import {
   DropboxResource
-} from "./chunk-5YOCVEUB.js";
+} from "./chunk-SWCDFEUK.js";
 import {
   normalizeDropboxConfig,
   redactDropboxConfig
 } from "./chunk-Q2IAILVC.js";
 import {
   BoxResource
-} from "./chunk-A4Z6DZ22.js";
+} from "./chunk-VWKUT4CW.js";
 import {
   normalizeBoxConfig,
   redactBoxConfig
@@ -44,24 +44,24 @@ import {
 } from "./chunk-54NTYJEO.js";
 import {
   GitHubResource
-} from "./chunk-YPT4JBUY.js";
+} from "./chunk-LV2G7VHL.js";
 import {
   GitHubCIResource
-} from "./chunk-ABTEGAFB.js";
+} from "./chunk-EZQ5HBAC.js";
 import {
   normalizeGitHubCIConfig,
   redactGitHubCIConfig
 } from "./chunk-H3I2KZIY.js";
 import {
   GDocsResource
-} from "./chunk-A7X4L4JM.js";
+} from "./chunk-JCC4CU2I.js";
 import {
   normalizeGDocsConfig,
   redactGDocsConfig
 } from "./chunk-H3BST2LI.js";
 import {
   GSheetsResource
-} from "./chunk-XRU5WXZX.js";
+} from "./chunk-ZEGAMJO2.js";
 import {
   normalizeGSheetsConfig,
   redactGSheetsConfig
@@ -72,24 +72,24 @@ import {
 } from "./chunk-W7FLHT65.js";
 import {
   TrelloResource
-} from "./chunk-ERELJ7BS.js";
+} from "./chunk-WAR4Q2NM.js";
 import {
   LinearResource
-} from "./chunk-YAVGCQUP.js";
+} from "./chunk-G2WCEUQL.js";
 import {
   normalizeLinearConfig,
   redactLinearConfig
 } from "./chunk-YUK3X3B4.js";
 import {
   NotionResource
-} from "./chunk-CASCUFK2.js";
+} from "./chunk-NOHWIBRX.js";
 import {
   normalizeNotionConfig,
   redactNotionConfig
 } from "./chunk-JZT4QGIP.js";
 import {
   LangfuseResource
-} from "./chunk-5DLOHQJ2.js";
+} from "./chunk-EM4J5EQS.js";
 import {
   normalizeLangfuseConfig,
   redactLangfuseConfig
@@ -101,10 +101,10 @@ import {
 import {
   MongoDBResource,
   MongoDBStore
-} from "./chunk-RLGWMJD3.js";
+} from "./chunk-GCFYZSVR.js";
 import {
   SlackResource
-} from "./chunk-C6NHEDHY.js";
+} from "./chunk-M5FVUIYP.js";
 import {
   normalizeSlackConfig,
   redactSlackConfig
@@ -115,14 +115,14 @@ import {
   SSH_COMMANDS,
   SSH_OPS,
   SSH_PROMPT
-} from "./chunk-5HCVKTP3.js";
+} from "./chunk-WHFUWWI6.js";
 import {
   normalizeSshConfig,
   redactSshConfig
 } from "./chunk-UGK4TAVK.js";
 import {
   DiscordResource
-} from "./chunk-LYDMMNL2.js";
+} from "./chunk-JAGJTM3Q.js";
 import {
   normalizeDiscordConfig,
   redactDiscordConfig
@@ -134,11 +134,11 @@ import {
 import {
   TENCENT_PROMPT,
   TencentResource
-} from "./chunk-L6JPBJAS.js";
+} from "./chunk-YAHRT6MB.js";
 import {
   ALIYUN_PROMPT,
   AliyunResource
-} from "./chunk-KTNDT45N.js";
+} from "./chunk-FQ33BYFR.js";
 import {
   redactAliyunConfig,
   resolvedAliyunEndpoint
@@ -146,7 +146,7 @@ import {
 import {
   SCALEWAY_PROMPT,
   ScalewayResource
-} from "./chunk-FXFDBF3P.js";
+} from "./chunk-3WIO7NBR.js";
 import {
   redactScalewayConfig,
   resolvedScalewayEndpoint
@@ -154,7 +154,7 @@ import {
 import {
   QINGSTOR_PROMPT,
   QingStorResource
-} from "./chunk-3IJSIVKT.js";
+} from "./chunk-QQBJC2FQ.js";
 import {
   redactQingStorConfig,
   resolvedQingStorEndpoint
@@ -162,15 +162,15 @@ import {
 import {
   PostgresResource,
   PostgresStore
-} from "./chunk-NHS7WLEQ.js";
+} from "./chunk-GS5AUKUO.js";
 import {
   CEPH_PROMPT,
   CephResource
-} from "./chunk-C6NHFMIP.js";
+} from "./chunk-IK2L4EN3.js";
 import {
   WASABI_PROMPT,
   WasabiResource
-} from "./chunk-O7ODGJYL.js";
+} from "./chunk-47AVIIOT.js";
 import {
   redactWasabiConfig,
   resolvedWasabiEndpoint
@@ -178,7 +178,7 @@ import {
 import {
   BACKBLAZE_PROMPT,
   BackblazeResource
-} from "./chunk-HQ4KWN76.js";
+} from "./chunk-X3G37FXT.js";
 import {
   redactBackblazeConfig,
   resolvedBackblazeEndpoint
@@ -186,7 +186,7 @@ import {
 import {
   DIGITALOCEAN_PROMPT,
   DigitalOceanResource
-} from "./chunk-AJICZLHT.js";
+} from "./chunk-KPULTUOK.js";
 import {
   redactDigitalOceanConfig,
   resolvedDigitalOceanEndpoint
@@ -198,26 +198,26 @@ import {
 import {
   HF_DATASETS_PROMPT,
   HfDatasetsResource
-} from "./chunk-RQYEEA2O.js";
+} from "./chunk-N5FSLVKO.js";
 import {
   HF_MODELS_PROMPT,
   HfModelsResource
-} from "./chunk-WL7HS7EM.js";
+} from "./chunk-UINQOUZR.js";
 import {
   HF_SPACES_PROMPT,
   HfSpacesResource
-} from "./chunk-OYV2DN66.js";
+} from "./chunk-X5HF2OFP.js";
 import {
   MINIO_PROMPT,
   MinIOResource
-} from "./chunk-Q6CDMOM6.js";
+} from "./chunk-7CW3BMPH.js";
 import {
   redactMinIOConfig
 } from "./chunk-DYXEITK3.js";
 import {
   SEAWEEDFS_PROMPT,
   SeaweedFSResource
-} from "./chunk-3T3RMDNX.js";
+} from "./chunk-AUHSTJJ3.js";
 import {
   redactSeaweedFSConfig
 } from "./chunk-2CC5VW7K.js";
@@ -227,21 +227,21 @@ import {
 import {
   OCIResource,
   OCI_PROMPT
-} from "./chunk-PJBQKMCD.js";
+} from "./chunk-DM4GSE26.js";
 import {
   redactOciConfig
 } from "./chunk-RQK5UPMP.js";
 import {
   R2Resource,
   R2_PROMPT
-} from "./chunk-B6SXRCBO.js";
+} from "./chunk-ZGSER5TG.js";
 import {
   redactR2Config
 } from "./chunk-LAJJPLEV.js";
 import {
   SUPABASE_PROMPT,
   SupabaseResource
-} from "./chunk-BYTU2YC3.js";
+} from "./chunk-HGCRXJGP.js";
 import {
   redactSupabaseConfig,
   resolvedSupabaseEndpoint
@@ -249,7 +249,7 @@ import {
 import {
   HF_BUCKETS_PROMPT,
   HfBucketsResource
-} from "./chunk-G5BZE7UA.js";
+} from "./chunk-HJJMP6IX.js";
 import {
   HF_COMMANDS,
   HF_OPS,
@@ -259,7 +259,7 @@ import {
   HfDatasetsAccessor,
   HfModelsAccessor,
   HfSpacesAccessor
-} from "./chunk-WSGEIVY3.js";
+} from "./chunk-TURD42QO.js";
 import {
   HF_ENDPOINT,
   assertHfRepoId,
@@ -273,7 +273,7 @@ import {
   DISK_OPS,
   DISK_PROMPT,
   DiskResource
-} from "./chunk-PBBG7VFT.js";
+} from "./chunk-XWVDS66D.js";
 import "./chunk-U6QSXTUS.js";
 import {
   REDIS_COMMANDS,
@@ -283,7 +283,7 @@ import {
   RedisResource,
   RedisStore,
   stat
-} from "./chunk-N72CAZEH.js";
+} from "./chunk-IDYHQQOH.js";
 import {
   loadOptionalPeer
 } from "./chunk-E2ISWXLB.js";
@@ -291,14 +291,14 @@ import {
   DatabricksVolumeResource,
   loadDatabricksProfile,
   parseDatabricksCfg
-} from "./chunk-JZQHKDSY.js";
+} from "./chunk-RNQN2FOU.js";
 import {
   GCSResource,
   GCS_PROMPT
-} from "./chunk-IQVNVTOP.js";
+} from "./chunk-I5THIMPP.js";
 import {
   S3Resource
-} from "./chunk-MHCMHKM6.js";
+} from "./chunk-TA3WMOMU.js";
 import {
   redactConfig
 } from "./chunk-UT2OPSN4.js";
@@ -312,14 +312,14 @@ export * from "@struktoai/mirage-core";
 
 // src/workspace.ts
 import { readFileSync } from "fs";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import {
   createShellParser,
   Workspace as CoreWorkspace
 } from "@struktoai/mirage-core";
 
 // src/workspace/fuse.ts
-import { rmSync } from "fs";
+import { rmdirSync } from "fs";
 
 // src/fuse/mount.ts
 import { execSync } from "child_process";
@@ -377,6 +377,9 @@ var MirageFS = class {
   root;
   prefixes;
   handles = /* @__PURE__ */ new Map();
+  // In-memory extended attributes, keyed by FUSE path. Backends have no POSIX
+  // xattrs, so these are advisory and never persisted; see setxattr.
+  xattrs = /* @__PURE__ */ new Map();
   prefetchCache = /* @__PURE__ */ new Map();
   prefetchInflight = /* @__PURE__ */ new Map();
   nextFh = 1;
@@ -392,9 +395,9 @@ var MirageFS = class {
     this.gid = typeof process.getgid === "function" ? process.getgid() : 0;
   }
   // ── helpers ──────────────────────────────────────────────────────
-  resolve(path) {
-    if (this.root === "") return path;
-    return path === "/" ? this.root : this.root + path;
+  resolve(path2) {
+    if (this.root === "") return path2;
+    return path2 === "/" ? this.root : this.root + path2;
   }
   whoamiContent() {
     const lines = [`agent: ${this.agentId}`, "cwd: /", `mounts: ${this.prefixes.join(", ")}`];
@@ -424,8 +427,8 @@ var MirageFS = class {
       gid: this.gid
     };
   }
-  isVirtualDir(path) {
-    const bare = rstripSlash(path);
+  isVirtualDir(path2) {
+    const bare = rstripSlash(path2);
     const normalized = bare + "/";
     for (const p of this.prefixes) {
       const pBare = rstripSlash(p);
@@ -433,8 +436,8 @@ var MirageFS = class {
     }
     return false;
   }
-  virtualChildren(path) {
-    const normalized = path === "/" ? "/" : rstripSlash(path) + "/";
+  virtualChildren(path2) {
+    const normalized = path2 === "/" ? "/" : rstripSlash(path2) + "/";
     const children = /* @__PURE__ */ new Set();
     for (const p of this.prefixes) {
       if (p.startsWith(normalized) && p !== normalized) {
@@ -445,21 +448,21 @@ var MirageFS = class {
     }
     return [...children].sort();
   }
-  cachedSize(path) {
+  cachedSize(path2) {
     for (const ctx of this.handles.values()) {
-      if (ctx.path === path && ctx.data !== void 0) return ctx.data.byteLength;
+      if (ctx.path === path2 && ctx.data !== void 0) return ctx.data.byteLength;
     }
-    const entry = this.prefetchCache.get(path);
+    const entry = this.prefetchCache.get(path2);
     if (entry !== void 0 && entry.expires > Date.now()) return entry.data.byteLength;
     return null;
   }
-  cachedData(path) {
+  cachedData(path2) {
     for (const ctx of this.handles.values()) {
-      if (ctx.path === path && ctx.data !== void 0) return ctx.data;
+      if (ctx.path === path2 && ctx.data !== void 0) return ctx.data;
     }
-    const entry = this.prefetchCache.get(path);
+    const entry = this.prefetchCache.get(path2);
     if (entry !== void 0 && entry.expires > Date.now()) return entry.data;
-    if (entry !== void 0) this.prefetchCache.delete(path);
+    if (entry !== void 0) this.prefetchCache.delete(path2);
     return null;
   }
   /**
@@ -469,23 +472,23 @@ var MirageFS = class {
    * libfuse's `direct_io` flag — without a real size from getattr, the kernel
    * decides the file is empty and never issues read().
    */
-  async prefetch(path) {
-    const cached = this.cachedData(path);
+  async prefetch(path2) {
+    const cached = this.cachedData(path2);
     if (cached !== null) return cached;
-    const inflight = this.prefetchInflight.get(path);
+    const inflight = this.prefetchInflight.get(path2);
     if (inflight !== void 0) return inflight;
     const promise = (async () => {
       try {
-        const data = await this.ws.fs.readFile(this.resolve(path));
-        this.prefetchCache.set(path, { data, expires: Date.now() + PREFETCH_TTL_MS });
+        const data = await this.ws.fs.readFile(this.resolve(path2));
+        this.prefetchCache.set(path2, { data, expires: Date.now() + PREFETCH_TTL_MS });
         return data;
       } catch {
         return null;
       } finally {
-        this.prefetchInflight.delete(path);
+        this.prefetchInflight.delete(path2);
       }
     })();
-    this.prefetchInflight.set(path, promise);
+    this.prefetchInflight.set(path2, promise);
     return promise;
   }
   /** Drain and return accumulated op records (mirrors Python's drain_ops). */
@@ -494,8 +497,8 @@ var MirageFS = class {
     this.ws.records.length = 0;
     return records;
   }
-  async writeFile(path, data) {
-    await this.ws.dispatch("write", this.resolve(path), [data]);
+  async writeFile(path2, data) {
+    await this.ws.dispatch("write", this.resolve(path2), [data]);
   }
   // ── FUSE op surface (mirrors mfusepy Operations) ─────────────────
   ops() {
@@ -519,60 +522,64 @@ var MirageFS = class {
       chmod: this.chmod.bind(this),
       chown: this.chown.bind(this),
       access: this.access.bind(this),
+      setxattr: this.setxattr.bind(this),
+      getxattr: this.getxattr.bind(this),
+      listxattr: this.listxattr.bind(this),
+      removexattr: this.removexattr.bind(this),
       statfs: this.statfs.bind(this)
     };
   }
-  getattr(path, cb) {
+  getattr(path2, cb) {
     void (async () => {
-      if (path === "/" || path === MIRAGE_DIR) {
+      if (path2 === "/" || path2 === MIRAGE_DIR) {
         cb(0, this.dirStat());
         return;
       }
-      if (path === MIRAGE_WHOAMI) {
+      if (path2 === MIRAGE_WHOAMI) {
         cb(0, this.fileStat(this.whoamiContent().byteLength));
         return;
       }
-      const name = path.slice(path.lastIndexOf("/") + 1);
+      const name = path2.slice(path2.lastIndexOf("/") + 1);
       if (isMacosMetadata(name)) {
         cb(ENOENT);
         return;
       }
-      if (this.isVirtualDir(path)) {
+      if (this.isVirtualDir(path2)) {
         cb(0, this.dirStat());
         return;
       }
       try {
-        const s = await this.ws.fs.stat(this.resolve(path));
+        const s = await this.ws.fs.stat(this.resolve(path2));
         if (s.type === FileType.DIRECTORY) {
           cb(0, this.dirStat());
           return;
         }
         let size = s.size;
-        size ??= this.cachedSize(path) ?? UNKNOWN_SIZE_SENTINEL;
+        size ??= this.cachedSize(path2) ?? UNKNOWN_SIZE_SENTINEL;
         cb(0, this.fileStat(size));
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  fgetattr(path, fd, cb) {
+  fgetattr(path2, fd, cb) {
     const ctx = this.handles.get(fd);
     if (ctx?.data !== void 0) {
       cb(0, this.fileStat(ctx.data.byteLength));
       return;
     }
-    this.getattr(path, cb);
+    this.getattr(path2, cb);
   }
-  readdir(path, cb) {
+  readdir(path2, cb) {
     void (async () => {
-      if (path === MIRAGE_DIR) {
+      if (path2 === MIRAGE_DIR) {
         cb(0, [".", "..", "whoami"]);
         return;
       }
-      const names = new Set(this.virtualChildren(path));
-      if (path === "/") names.add(".mirage");
+      const names = new Set(this.virtualChildren(path2));
+      if (path2 === "/") names.add(".mirage");
       try {
-        const entries = await this.ws.fs.readdir(this.resolve(path));
+        const entries = await this.ws.fs.readdir(this.resolve(path2));
         for (const e of entries) {
           const part = rstripSlash(e).split("/").pop() ?? "";
           if (part !== "" && !isMacosMetadata(part)) names.add(part);
@@ -586,9 +593,9 @@ var MirageFS = class {
       cb(0, [".", "..", ...[...names].sort()]);
     })();
   }
-  read(path, fd, buf, len, pos, cb) {
+  read(path2, fd, buf, len, pos, cb) {
     void (async () => {
-      if (path === MIRAGE_WHOAMI) {
+      if (path2 === MIRAGE_WHOAMI) {
         const data = this.whoamiContent();
         const slice = data.subarray(pos, pos + len);
         buf.set(slice, 0);
@@ -598,10 +605,10 @@ var MirageFS = class {
       const ctx = this.handles.get(fd);
       try {
         if (ctx !== void 0 && ctx.data === void 0) {
-          const cached = this.cachedData(path);
-          ctx.data = cached ?? await this.ws.fs.readFile(this.resolve(path));
+          const cached = this.cachedData(path2);
+          ctx.data = cached ?? await this.ws.fs.readFile(this.resolve(path2));
         }
-        const data = ctx?.data ?? this.cachedData(path) ?? await this.ws.fs.readFile(this.resolve(path));
+        const data = ctx?.data ?? this.cachedData(path2) ?? await this.ws.fs.readFile(this.resolve(path2));
         const slice = data.subarray(pos, pos + len);
         buf.set(slice, 0);
         cb(slice.byteLength);
@@ -610,7 +617,7 @@ var MirageFS = class {
       }
     })();
   }
-  write(path, fd, buf, len, pos, cb) {
+  write(path2, fd, buf, len, pos, cb) {
     const ctx = this.handles.get(fd);
     const data = new Uint8Array(buf.subarray(0, len));
     if (ctx !== void 0) {
@@ -623,7 +630,7 @@ var MirageFS = class {
       try {
         let existing = new Uint8Array(0);
         try {
-          existing = await this.ws.fs.readFile(this.resolve(path), { raw: true });
+          existing = await this.ws.fs.readFile(this.resolve(path2), { raw: true });
         } catch {
         }
         let merged = existing;
@@ -642,45 +649,46 @@ var MirageFS = class {
           }
           merged = out;
         }
-        await this.writeFile(path, merged);
+        await this.writeFile(path2, merged);
         cb(len);
       } catch {
         cb(0);
       }
     })();
   }
-  create(path, _mode, cb) {
+  create(path2, _mode, cb) {
     void (async () => {
       try {
         try {
-          await this.ws.dispatch("create", this.resolve(path));
+          await this.ws.dispatch("create", this.resolve(path2));
         } catch (dispatchErr) {
           const msg = (dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr)).toLowerCase();
           if (!msg.includes("no op")) throw dispatchErr;
-          await this.writeFile(path, new Uint8Array(0));
+          await this.writeFile(path2, new Uint8Array(0));
         }
         const fh = this.nextFh++;
-        this.handles.set(fh, { path });
+        this.handles.set(fh, { path: path2 });
         cb(0, fh);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  mkdir(path, _mode, cb) {
+  mkdir(path2, _mode, cb) {
     void (async () => {
       try {
-        await this.ws.fs.mkdir(this.resolve(path));
+        await this.ws.fs.mkdir(this.resolve(path2));
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  unlink(path, cb) {
+  unlink(path2, cb) {
     void (async () => {
       try {
-        await this.ws.fs.unlink(this.resolve(path));
+        await this.ws.fs.unlink(this.resolve(path2));
+        this.xattrs.delete(path2);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
@@ -691,42 +699,48 @@ var MirageFS = class {
     void (async () => {
       try {
         await this.ws.fs.rename(this.resolve(src), this.resolve(dst));
+        const moved = this.xattrs.get(src);
+        if (moved !== void 0) {
+          this.xattrs.delete(src);
+          this.xattrs.set(dst, moved);
+        }
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  rmdir(path, cb) {
+  rmdir(path2, cb) {
     void (async () => {
       try {
         try {
-          const entries = await this.ws.fs.readdir(this.resolve(path));
+          const entries = await this.ws.fs.readdir(this.resolve(path2));
           if (entries.length > 0) {
             cb(ENOTEMPTY);
             return;
           }
         } catch {
         }
-        await this.ws.fs.rmdir(this.resolve(path));
+        await this.ws.fs.rmdir(this.resolve(path2));
+        this.xattrs.delete(path2);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  truncate(path, size, cb) {
+  truncate(path2, size, cb) {
     void (async () => {
       try {
         try {
-          await this.ws.dispatch("truncate", this.resolve(path), [size]);
+          await this.ws.dispatch("truncate", this.resolve(path2), [size]);
         } catch (dispatchErr) {
           const msg = (dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr)).toLowerCase();
           if (!msg.includes("no op")) throw dispatchErr;
-          const data = await this.ws.fs.readFile(this.resolve(path), { raw: true }).catch(() => new Uint8Array(0));
+          const data = await this.ws.fs.readFile(this.resolve(path2), { raw: true }).catch(() => new Uint8Array(0));
           const out = new Uint8Array(size);
           out.set(data.subarray(0, Math.min(data.byteLength, size)), 0);
-          await this.writeFile(path, out);
+          await this.writeFile(path2, out);
         }
         cb(0);
       } catch (err) {
@@ -750,36 +764,86 @@ var MirageFS = class {
   // chmod / chown / utimens / access are no-ops for the filesystem but must
   // validate path existence — callers like `touch`/`chmod` on a missing file
   // should fail with ENOENT, not silently succeed.
-  chmod(path, _mode, cb) {
-    this.getattrValidate(path, cb);
+  chmod(path2, _mode, cb) {
+    this.getattrValidate(path2, cb);
+  }
+  chown(path2, _uid, _gid, cb) {
+    this.getattrValidate(path2, cb);
+  }
+  utimens(path2, _atime, _mtime, cb) {
+    this.getattrValidate(path2, cb);
+  }
+  access(path2, _amode, cb) {
+    this.getattrValidate(path2, cb);
+  }
+  // Mirage backends (S3, etc.) have no POSIX extended attributes, so there is
+  // nothing to persist xattrs to. We keep them in memory per mount so tools that
+  // probe or set xattrs (sandbox runtimes, rsync -aX, tar --xattrs, cp -p, macOS
+  // Finder writing com.apple.*) succeed instead of failing with ENOTSUP. The
+  // values live only for the mount's lifetime and are never written to the
+  // backend.
+  setxattr(path2, name, value, _position, _flags, cb) {
+    this.getattr(path2, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      let attrs = this.xattrs.get(path2);
+      if (attrs === void 0) {
+        attrs = /* @__PURE__ */ new Map();
+        this.xattrs.set(path2, attrs);
+      }
+      attrs.set(name, Buffer.from(value));
+      cb(0);
+    });
   }
-  chown(path, _uid, _gid, cb) {
-    this.getattrValidate(path, cb);
+  getxattr(path2, name, _position, cb) {
+    this.getattr(path2, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      cb(0, this.xattrs.get(path2)?.get(name));
+    });
   }
-  utimens(path, _atime, _mtime, cb) {
-    this.getattrValidate(path, cb);
+  listxattr(path2, cb) {
+    this.getattr(path2, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      const attrs = this.xattrs.get(path2);
+      cb(0, attrs ? [...attrs.keys()] : []);
+    });
   }
-  access(path, _amode, cb) {
-    this.getattrValidate(path, cb);
+  removexattr(path2, name, cb) {
+    this.getattr(path2, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      this.xattrs.get(path2)?.delete(name);
+      cb(0);
+    });
   }
-  getattrValidate(path, cb) {
-    this.getattr(path, (code) => {
+  getattrValidate(path2, cb) {
+    this.getattr(path2, (code) => {
       cb(code);
     });
   }
-  open(path, _flags, cb) {
+  open(path2, _flags, cb) {
     void (async () => {
-      if (path === MIRAGE_WHOAMI) {
+      if (path2 === MIRAGE_WHOAMI) {
         const fh = this.nextFh++;
-        this.handles.set(fh, { path });
+        this.handles.set(fh, { path: path2 });
         cb(0, fh);
         return;
       }
       try {
-        const s = await this.ws.fs.stat(this.resolve(path));
-        const ctx = { path };
+        const s = await this.ws.fs.stat(this.resolve(path2));
+        const ctx = { path: path2 };
         if (s.size === null && s.type !== FileType.DIRECTORY) {
-          const data = await this.prefetch(path);
+          const data = await this.prefetch(path2);
           if (data !== null) ctx.data = data;
         }
         const fh = this.nextFh++;
@@ -794,7 +858,7 @@ var MirageFS = class {
     this.handles.delete(fd);
     cb(0);
   }
-  flush(path, fd, cb) {
+  flush(path2, fd, cb) {
     const ctx = this.handles.get(fd);
     if (ctx?.writeBuf === void 0 || ctx.writeBuf.length === 0) {
       cb(0);
@@ -806,7 +870,7 @@ var MirageFS = class {
       try {
         let existing = new Uint8Array(0);
         try {
-          existing = await this.ws.fs.readFile(this.resolve(path), { raw: true });
+          existing = await this.ws.fs.readFile(this.resolve(path2), { raw: true });
         } catch {
         }
         let total = existing.byteLength;
@@ -818,15 +882,15 @@ var MirageFS = class {
         for (const [off, chunk] of writes) {
           merged.set(chunk, off);
         }
-        await this.writeFile(path, merged);
+        await this.writeFile(path2, merged);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  fsync(path, _datasync, fd, cb) {
-    this.flush(path, fd, cb);
+  fsync(path2, _datasync, fd, cb) {
+    this.flush(path2, fd, cb);
   }
 };
 
@@ -859,11 +923,13 @@ function forceUnmount(mountpoint) {
 async function mount(ws, options = {}) {
   const Fuse = await loadFuse();
   let mountpoint;
+  let ownsMountpoint = false;
   if (options.mountpoint !== void 0) {
     mkdirSync(options.mountpoint, { recursive: true });
     mountpoint = options.mountpoint;
   } else {
     mountpoint = mkdtempSync(join(tmpdir(), "mirage-fuse-"));
+    ownsMountpoint = true;
   }
   const agentId = options.agentId;
   const mfs = new MirageFS(ws, {
@@ -887,6 +953,7 @@ async function mount(ws, options = {}) {
   });
   return {
     mountpoint,
+    ownsMountpoint,
     unmount: () => new Promise((resolve, reject) => {
       fuse.unmount((err) => {
         if (err === null) resolve();
@@ -901,6 +968,13 @@ function mountBackground(ws, options = {}) {
 
 // src/workspace/fuse.ts
 var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function removeMountpointIfOwned(entry) {
+  if (!entry.ownsMountpoint) return;
+  try {
+    rmdirSync(entry.mountpoint);
+  } catch {
+  }
+}
 var FuseCleanupRegistry = class {
   mounts = /* @__PURE__ */ new Set();
   installed = false;
@@ -935,10 +1009,7 @@ var FuseCleanupRegistry = class {
   drainSync() {
     for (const entry of this.mounts) {
       forceUnmount(entry.mountpoint);
-      try {
-        rmSync(entry.mountpoint, { recursive: true, force: true });
-      } catch {
-      }
+      removeMountpointIfOwned(entry);
     }
     this.mounts.clear();
   }
@@ -946,61 +1017,81 @@ var FuseCleanupRegistry = class {
 var CLEANUP = new FuseCleanupRegistry();
 var FuseManager = class {
   handle = null;
-  externalMountpoint = null;
-  auto = false;
   cleanupEntry = null;
   get mountpoint() {
-    if (this.handle !== null) return this.handle.mountpoint;
-    return this.externalMountpoint;
-  }
-  set mountpoint(path) {
-    this.externalMountpoint = path;
+    return this.handle?.mountpoint ?? null;
   }
   async setup(ws, options = {}) {
     if (this.handle !== null) return this.handle.mountpoint;
-    this.handle = await mount(ws, options);
-    this.auto = true;
-    this.externalMountpoint = null;
-    this.cleanupEntry = { mountpoint: this.handle.mountpoint, handle: this.handle };
+    const handle = await mount(ws, options);
+    this.handle = handle;
+    this.cleanupEntry = {
+      mountpoint: handle.mountpoint,
+      handle,
+      // Preserve the ownership decision made by mount(); unmount cleanup must
+      // not infer ownership from path shape or whether the directory exists.
+      ownsMountpoint: handle.ownsMountpoint
+    };
     CLEANUP.register(this.cleanupEntry);
-    ws.setFuseMountpoint(this.handle.mountpoint, { owned: true });
-    return this.handle.mountpoint;
+    return handle.mountpoint;
   }
-  async unmount(ws) {
+  async unmount() {
     if (this.handle === null) {
-      if (ws !== void 0) ws.setFuseMountpoint(null);
-      this.externalMountpoint = null;
       return;
     }
     const mp = this.handle.mountpoint;
     try {
       await this.handle.unmount();
     } finally {
-      if (this.cleanupEntry !== null) {
-        CLEANUP.unregister(this.cleanupEntry);
+      const cleanupEntry = this.cleanupEntry;
+      if (cleanupEntry !== null) {
+        CLEANUP.unregister(cleanupEntry);
         this.cleanupEntry = null;
       }
       this.handle = null;
-      this.auto = false;
-      ws?.setFuseMountpoint(null);
-      try {
-        rmSync(mp, { recursive: true, force: true });
-      } catch {
-      }
+      removeMountpointIfOwned({
+        mountpoint: mp,
+        ownsMountpoint: cleanupEntry?.ownsMountpoint ?? false
+      });
     }
   }
-  async close(ws) {
-    if (this.auto) await this.unmount(ws);
+  async close() {
+    await this.unmount();
   }
 };
 
-// src/workspace.ts
+// src/workspace/mount_spec.ts
+var Mount = class {
+  constructor(resource, options = {}) {
+    this.resource = resource;
+    this.options = options;
+  }
+  resource;
+  options;
+};
+
+// src/compression_codecs.ts
+import { createRequire } from "module";
+import { registerCompressionCodec } from "@struktoai/mirage-core";
 var requireCjs = createRequire(import.meta.url);
+var { Bzip2 } = requireCjs("compressjs");
+var { xz } = requireCjs("@napi-rs/lzma");
+registerCompressionCodec("bzip2", {
+  compress: (bytes) => Promise.resolve(Uint8Array.from(Bzip2.compressFile(bytes))),
+  decompress: (bytes) => Promise.resolve(Uint8Array.from(Bzip2.decompressFile(bytes)))
+});
+registerCompressionCodec("xz", {
+  compress: async (bytes) => new Uint8Array(await xz.compress(Buffer.from(bytes))),
+  decompress: async (bytes) => new Uint8Array(await xz.decompress(Buffer.from(bytes)))
+});
+
+// src/workspace.ts
+var requireCjs2 = createRequire2(import.meta.url);
 var cachedParser = null;
 function loadShellParser() {
   if (cachedParser !== null) return cachedParser;
-  const enginePath = requireCjs.resolve("web-tree-sitter/web-tree-sitter.wasm");
-  const grammarPath = requireCjs.resolve("tree-sitter-bash/tree-sitter-bash.wasm");
+  const enginePath = requireCjs2.resolve("web-tree-sitter/web-tree-sitter.wasm");
+  const grammarPath = requireCjs2.resolve("tree-sitter-bash/tree-sitter-bash.wasm");
   cachedParser = createShellParser({
     engineWasm: readFileSync(enginePath),
     grammarWasm: readFileSync(grammarPath)
@@ -1008,29 +1099,38 @@ function loadShellParser() {
   return cachedParser;
 }
 var Workspace = class extends CoreWorkspace {
-  autoFuseManagers = /* @__PURE__ */ new Map();
-  fuseMountpointsMap = /* @__PURE__ */ new Map();
   fuseSetupPromise = null;
+  fuseMountpointsMap = /* @__PURE__ */ new Map();
+  fuseManagers = /* @__PURE__ */ new Map();
   constructor(resources, options = {}) {
-    super(resources, {
+    const bareResources = {};
+    const modeOverrides = { ...options.modeOverrides ?? {} };
+    const commandSafeguards = {
+      ...options.commandSafeguards ?? {}
+    };
+    const fuseTargets = [];
+    for (const [prefix, value] of Object.entries(resources)) {
+      if (value instanceof Mount) {
+        bareResources[prefix] = value.resource;
+        if (value.options.mode !== void 0) modeOverrides[prefix] = value.options.mode;
+        if (value.options.commandSafeguards !== void 0)
+          commandSafeguards[prefix] = value.options.commandSafeguards;
+        if (value.options.fuse !== void 0 && value.options.fuse !== false)
+          fuseTargets.push([prefix, value.options.fuse]);
+      } else {
+        bareResources[prefix] = value;
+      }
+    }
+    super(bareResources, {
       ...options,
+      ...Object.keys(modeOverrides).length > 0 ? { modeOverrides } : {},
+      ...Object.keys(commandSafeguards).length > 0 ? { commandSafeguards } : {},
       shellParserFactory: options.shellParserFactory ?? loadShellParser
     });
-    const fuseMounts = options.fuseMounts ?? {};
-    const setups = [];
-    for (const [prefix, target] of Object.entries(fuseMounts)) {
-      if (target === false) continue;
-      const fm = new FuseManager();
-      this.autoFuseManagers.set(prefix, fm);
-      const opts = {
-        rootPrefix: prefix,
-        ...typeof target === "string" ? { mountpoint: target } : {}
-      };
-      setups.push(
-        fm.setup(this, opts).then(
-          (mountpoint) => {
-            this.fuseMountpointsMap.set(prefix, mountpoint);
-          },
+    if (fuseTargets.length > 0) {
+      const setups = fuseTargets.map(
+        ([prefix, target]) => this.addFuseMount(prefix, typeof target === "string" ? target : void 0).then(
+          () => void 0,
           (err) => {
             process.stderr.write(
               `mirage: FUSE auto-mount failed for ${prefix}, continuing without it: ${err instanceof Error ? err.message : String(err)}
@@ -1039,41 +1139,226 @@ var Workspace = class extends CoreWorkspace {
           }
         )
       );
-    }
-    if (setups.length > 0) {
       this.fuseSetupPromise = Promise.all(setups).then(() => void 0);
     }
   }
-  /** Map each FUSE-exposed mount prefix to its live mountpoint. */
+  registerFuseMount(prefix, mountpoint) {
+    for (const [otherPrefix, otherMp] of this.fuseMountpointsMap) {
+      if (otherMp === mountpoint && otherPrefix !== prefix) {
+        throw new Error(
+          `FUSE mountpoint ${mountpoint} already used by prefix ${otherPrefix}; mounts need distinct paths`
+        );
+      }
+    }
+    this.fuseMountpointsMap.set(prefix, mountpoint);
+  }
+  /**
+   * Mount a workspace subtree under FUSE and own its lifecycle. Each mount gets
+   * its own {@link FuseManager}, so a workspace can expose any number of FUSE
+   * subtrees at once. A pinned mountpoint is collision-checked BEFORE mounting,
+   * so a clash never leaves a partial kernel mount.
+   */
+  async addFuseMount(prefix, mountpoint) {
+    if (mountpoint !== void 0) this.registerFuseMount(prefix, mountpoint);
+    const fm = new FuseManager();
+    this.fuseManagers.set(prefix, fm);
+    try {
+      const mp = await fm.setup(this, {
+        rootPrefix: prefix,
+        ...mountpoint !== void 0 ? { mountpoint } : {}
+      });
+      if (mountpoint === void 0) this.registerFuseMount(prefix, mp);
+      return mp;
+    } catch (err) {
+      this.fuseManagers.delete(prefix);
+      this.fuseMountpointsMap.delete(prefix);
+      throw err;
+    }
+  }
+  async removeFuseMount(prefix) {
+    const fm = this.fuseManagers.get(prefix);
+    this.fuseManagers.delete(prefix);
+    if (fm !== void 0) await fm.unmount();
+    this.fuseMountpointsMap.delete(prefix);
+  }
   get fuseMountpoints() {
     return Object.fromEntries(this.fuseMountpointsMap);
   }
-  async ensureFuseReady() {
+  get fuseMountpoint() {
+    if (this.fuseMountpointsMap.size === 0) return null;
+    if (this.fuseMountpointsMap.size > 1) {
+      throw new Error("multiple FUSE mounts active; use fuseMountpoints to select one by prefix");
+    }
+    return this.fuseMountpointsMap.values().next().value ?? null;
+  }
+  /** Await the eager per-mount fuse mounts started in the constructor. */
+  async fuseReady() {
     if (this.fuseSetupPromise !== null) {
       await this.fuseSetupPromise;
       this.fuseSetupPromise = null;
     }
   }
   async execute(command, options = {}) {
-    await this.ensureFuseReady();
+    await this.fuseReady();
     return super.execute(command, options);
   }
   async close() {
-    await this.ensureFuseReady().catch(() => void 0);
-    for (const fm of this.autoFuseManagers.values()) {
-      await fm.close(this);
-    }
+    await this.fuseReady().catch(() => void 0);
+    for (const fm of this.fuseManagers.values()) await fm.unmount();
+    this.fuseManagers.clear();
+    this.fuseMountpointsMap.clear();
     await super.close();
   }
 };
 
+// src/observe/disk_store.ts
+import { appendFile, mkdir, readdir, readFile, rmdir, unlink, writeFile } from "fs/promises";
+import path from "path";
+var DiskObserverStore = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  abs(key) {
+    return path.join(this.root, key.replace(/^\/+/, ""));
+  }
+  async append(key, data) {
+    const absPath = this.abs(key);
+    await mkdir(path.dirname(absPath), { recursive: true });
+    await appendFile(absPath, data);
+  }
+  async write(key, data) {
+    const absPath = this.abs(key);
+    await mkdir(path.dirname(absPath), { recursive: true });
+    await writeFile(absPath, data);
+  }
+  readAll() {
+    return this.readMatching("");
+  }
+  async readMatching(suffix) {
+    const out = /* @__PURE__ */ new Map();
+    const { files } = await this.walk();
+    for (const absPath of files) {
+      const rel = "/" + path.relative(this.root, absPath);
+      if (!rel.endsWith(suffix)) continue;
+      out.set(rel, new Uint8Array(await readFile(absPath)));
+    }
+    return out;
+  }
+  async clear() {
+    const { files, dirs } = await this.walk();
+    for (const absPath of files) await unlink(absPath);
+    for (const d of [...dirs].reverse()) await rmdir(d);
+  }
+  close() {
+    return Promise.resolve();
+  }
+  async walk() {
+    const files = [];
+    const dirs = [];
+    const stack = [this.root];
+    while (stack.length > 0) {
+      const d = stack.pop();
+      if (d === void 0) break;
+      let entries;
+      try {
+        entries = await readdir(d, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      dirs.push(d);
+      for (const entry of entries) {
+        const full = path.join(d, entry.name);
+        if (entry.isDirectory()) stack.push(full);
+        else files.push(full);
+      }
+    }
+    return { files, dirs };
+  }
+};
+
+// src/observe/redis_store.ts
+var RedisObserverStore = class {
+  url;
+  prefix;
+  indexKey;
+  clientPromise = null;
+  constructor(options = {}) {
+    this.url = options.url ?? "redis://localhost:6379/0";
+    this.prefix = options.keyPrefix ?? "mirage:observer:";
+    this.indexKey = `${this.prefix}keys`;
+  }
+  async client() {
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("redis"),
+        { feature: "RedisObserverStore", packageName: "redis" }
+      );
+      const c = mod.createClient({
+        url: this.url,
+        socket: { reconnectStrategy: false }
+      });
+      await c.connect();
+      return c;
+    })();
+    return this.clientPromise;
+  }
+  async append(key, data) {
+    const c = await this.client();
+    const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    await c.multi().append(`${this.prefix}${key}`, buf).sAdd(this.indexKey, key).exec();
+  }
+  async write(key, data) {
+    const c = await this.client();
+    const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    await c.multi().set(`${this.prefix}${key}`, buf).sAdd(this.indexKey, key).exec();
+  }
+  readAll() {
+    return this.readMatching("");
+  }
+  async readMatching(suffix) {
+    const paths = (await this.indexedPaths()).filter((p) => p.endsWith(suffix));
+    return this.readPaths(paths);
+  }
+  async indexedPaths() {
+    const c = await this.client();
+    const members = await c.sMembers(this.indexKey);
+    return [...members].sort();
+  }
+  async readPaths(paths) {
+    const out = /* @__PURE__ */ new Map();
+    if (paths.length === 0) return out;
+    const c = await this.client();
+    const mod = await import("redis");
+    const mapping = { [mod.RESP_TYPES.BLOB_STRING]: Buffer };
+    const typed = c;
+    const values = await typed.withTypeMapping(mapping).mGet(paths.map((p) => `${this.prefix}${p}`));
+    paths.forEach((p, i) => {
+      const raw = values[i];
+      out.set(p, raw === null || raw === void 0 ? new Uint8Array() : new Uint8Array(raw));
+    });
+    return out;
+  }
+  async clear() {
+    const c = await this.client();
+    const paths = await this.indexedPaths();
+    const keys = [...paths.map((p) => `${this.prefix}${p}`), this.indexKey];
+    if (keys.length > 0) await c.del(keys);
+  }
+  async close() {
+    if (this.clientPromise === null) return;
+    const c = await this.clientPromise;
+    await c.quit();
+  }
+};
+
 // src/fs_monkey.ts
 import { Buffer as Buffer2 } from "buffer";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 import { FileType as FileType2 } from "@struktoai/mirage-core";
-var requireCjs2 = createRequire2(import.meta.url);
-var fs = requireCjs2("node:fs");
-var fsMonkey = requireCjs2("fs-monkey");
+var requireCjs3 = createRequire3(import.meta.url);
+var fs = requireCjs3("node:fs");
+var fsMonkey = requireCjs3("fs-monkey");
 var { patchFs } = fsMonkey;
 function mountedPath(ws, p) {
   try {
@@ -1501,7 +1786,7 @@ var LanceDBStore = class {
 var REMOTE_SCHEMES = ["s3://", "gs://", "az://", "hf://", "db://"];
 var LanceDBResource = class extends BaseResource {
   kind = ResourceName.LANCEDB;
-  isRemote;
+  cachesReads;
   indexTtl = 0;
   prompt = LANCEDB_PROMPT;
   config;
@@ -1511,7 +1796,7 @@ var LanceDBResource = class extends BaseResource {
     super();
     const config = "config" in options ? options.config : options;
     this.config = resolveLanceDBConfig(config);
-    this.isRemote = REMOTE_SCHEMES.some((scheme) => this.config.uri.startsWith(scheme));
+    this.cachesReads = REMOTE_SCHEMES.some((scheme) => this.config.uri.startsWith(scheme));
     this.store = new LanceDBStore(this.config);
     this.accessor = new LanceDBAccessor(this.store, this.config);
   }
@@ -1546,207 +1831,207 @@ var REGISTRY = {
     return new RAMResource();
   },
   disk: async (config) => {
-    const { DiskResource: DiskResource2 } = await import("./disk-POACMF4G.js");
+    const { DiskResource: DiskResource2 } = await import("./disk-XVLBCVKE.js");
     const norm = normalizeFields(config);
     return new DiskResource2(norm);
   },
   redis: async (config) => {
-    const { RedisResource: RedisResource2 } = await import("./redis-S6GIPA4Z.js");
+    const { RedisResource: RedisResource2 } = await import("./redis-V5ULXULL.js");
     const norm = normalizeFields(config);
     return new RedisResource2(norm);
   },
   s3: async (config) => {
-    const { S3Resource: S3Resource2 } = await import("./s3-GMPUJ65D.js");
+    const { S3Resource: S3Resource2 } = await import("./s3-4OIOCAAT.js");
     const { normalizeS3Config } = await import("./config-QWCY3LBQ.js");
     return new S3Resource2(normalizeS3Config(config));
   },
   gcs: async (config) => {
-    const { GCSResource: GCSResource2 } = await import("./gcs-SMIE4VMT.js");
+    const { GCSResource: GCSResource2 } = await import("./gcs-EMEYU2XT.js");
     const { normalizeGcsConfig } = await import("./config-VM526IKB.js");
     return new GCSResource2(normalizeGcsConfig(config));
   },
   oci: async (config) => {
-    const { OCIResource: OCIResource2 } = await import("./oci-NURLWPL2.js");
+    const { OCIResource: OCIResource2 } = await import("./oci-ZLVECXTW.js");
     const { normalizeOciConfig } = await import("./config-KYTRXAB2.js");
     return new OCIResource2(normalizeOciConfig(config));
   },
   r2: async (config) => {
-    const { R2Resource: R2Resource2 } = await import("./r2-FSZK7IFI.js");
+    const { R2Resource: R2Resource2 } = await import("./r2-RPK25ANI.js");
     const { normalizeR2Config } = await import("./config-KMVCVBYN.js");
     return new R2Resource2(normalizeR2Config(config));
   },
   hf_buckets: async (config) => {
-    const { HfBucketsResource: HfBucketsResource2 } = await import("./hf_buckets-RIOMV7WG.js");
+    const { HfBucketsResource: HfBucketsResource2 } = await import("./hf_buckets-DTKXKKFF.js");
     const { normalizeHfBucketsConfig: normalizeHfBucketsConfig2 } = await import("./config-CVZ2AGCO.js");
     return new HfBucketsResource2(normalizeHfBucketsConfig2(config));
   },
   hf_datasets: async (config) => {
-    const { HfDatasetsResource: HfDatasetsResource2 } = await import("./hf_datasets-QF4BQ3OK.js");
+    const { HfDatasetsResource: HfDatasetsResource2 } = await import("./hf_datasets-55C4APKR.js");
     const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-CVZ2AGCO.js");
     return new HfDatasetsResource2(normalizeHfRepoConfig2(config));
   },
   hf_models: async (config) => {
-    const { HfModelsResource: HfModelsResource2 } = await import("./hf_models-62GC2HPZ.js");
+    const { HfModelsResource: HfModelsResource2 } = await import("./hf_models-RO5JR36V.js");
     const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-CVZ2AGCO.js");
     return new HfModelsResource2(normalizeHfRepoConfig2(config));
   },
   hf_spaces: async (config) => {
-    const { HfSpacesResource: HfSpacesResource2 } = await import("./hf_spaces-NVSMUNRM.js");
+    const { HfSpacesResource: HfSpacesResource2 } = await import("./hf_spaces-ZVZ3EDRX.js");
     const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-CVZ2AGCO.js");
     return new HfSpacesResource2(normalizeHfRepoConfig2(config));
   },
   supabase: async (config) => {
-    const { SupabaseResource: SupabaseResource2 } = await import("./supabase-HLWNHBBE.js");
+    const { SupabaseResource: SupabaseResource2 } = await import("./supabase-6CFTOKGZ.js");
     const { normalizeSupabaseConfig } = await import("./config-GE4W4ZJC.js");
     return new SupabaseResource2(normalizeSupabaseConfig(config));
   },
   databricks_volume: async (config) => {
-    const { DatabricksVolumeResource: DatabricksVolumeResource2 } = await import("./databricks_volume-HNQ4DJVJ.js");
+    const { DatabricksVolumeResource: DatabricksVolumeResource2 } = await import("./databricks_volume-7XOUYSTY.js");
     const { normalizeDatabricksVolumeConfig } = await import("@struktoai/mirage-core");
     return DatabricksVolumeResource2.create(normalizeDatabricksVolumeConfig(config));
   },
   minio: async (config) => {
-    const { MinIOResource: MinIOResource2 } = await import("./minio-L3XE6PQS.js");
+    const { MinIOResource: MinIOResource2 } = await import("./minio-HZ576XFQ.js");
     const { normalizeMinIOConfig } = await import("./config-34LHOGLM.js");
     return new MinIOResource2(normalizeMinIOConfig(config));
   },
   ceph: async (config) => {
-    const { CephResource: CephResource2 } = await import("./ceph-TNN4I2FT.js");
+    const { CephResource: CephResource2 } = await import("./ceph-S2VOYO6G.js");
     const { normalizeCephConfig } = await import("./config-ZFJYQZCH.js");
     return new CephResource2(normalizeCephConfig(config));
   },
   seaweedfs: async (config) => {
-    const { SeaweedFSResource: SeaweedFSResource2 } = await import("./seaweedfs-J3EPUEPE.js");
+    const { SeaweedFSResource: SeaweedFSResource2 } = await import("./seaweedfs-QSWKF2FN.js");
     const { normalizeSeaweedFSConfig } = await import("./config-GHRUKEQ6.js");
     return new SeaweedFSResource2(normalizeSeaweedFSConfig(config));
   },
   wasabi: async (config) => {
-    const { WasabiResource: WasabiResource2 } = await import("./wasabi-SOZKPMRQ.js");
+    const { WasabiResource: WasabiResource2 } = await import("./wasabi-6Z4DC5S5.js");
     const { normalizeWasabiConfig } = await import("./config-QAA646XB.js");
     return new WasabiResource2(normalizeWasabiConfig(config));
   },
   backblaze: async (config) => {
-    const { BackblazeResource: BackblazeResource2 } = await import("./backblaze-OHW57DLK.js");
+    const { BackblazeResource: BackblazeResource2 } = await import("./backblaze-TDFD23QO.js");
     const { normalizeBackblazeConfig } = await import("./config-WDAZFXYD.js");
     return new BackblazeResource2(normalizeBackblazeConfig(config));
   },
   digitalocean: async (config) => {
-    const { DigitalOceanResource: DigitalOceanResource2 } = await import("./digitalocean-6SPR4S7V.js");
+    const { DigitalOceanResource: DigitalOceanResource2 } = await import("./digitalocean-3CQ4CPPZ.js");
     const { normalizeDigitalOceanConfig } = await import("./config-Q45Y46YT.js");
     return new DigitalOceanResource2(normalizeDigitalOceanConfig(config));
   },
   tencent: async (config) => {
-    const { TencentResource: TencentResource2 } = await import("./tencent-YDO73XBD.js");
+    const { TencentResource: TencentResource2 } = await import("./tencent-IWZZOSQ4.js");
     const { normalizeTencentConfig } = await import("./config-QNMKWJ4M.js");
     return new TencentResource2(normalizeTencentConfig(config));
   },
   aliyun: async (config) => {
-    const { AliyunResource: AliyunResource2 } = await import("./aliyun-TMZRUYCG.js");
+    const { AliyunResource: AliyunResource2 } = await import("./aliyun-JMJ3PFYY.js");
     const { normalizeAliyunConfig } = await import("./config-HKRMKD76.js");
     return new AliyunResource2(normalizeAliyunConfig(config));
   },
   scaleway: async (config) => {
-    const { ScalewayResource: ScalewayResource2 } = await import("./scaleway-5VM55Y6D.js");
+    const { ScalewayResource: ScalewayResource2 } = await import("./scaleway-CCWCLUHB.js");
     const { normalizeScalewayConfig } = await import("./config-EO23EY62.js");
     return new ScalewayResource2(normalizeScalewayConfig(config));
   },
   qingstor: async (config) => {
-    const { QingStorResource: QingStorResource2 } = await import("./qingstor-W55D5YFO.js");
+    const { QingStorResource: QingStorResource2 } = await import("./qingstor-YLP6K3L4.js");
     const { normalizeQingStorConfig } = await import("./config-IVY5EQQ2.js");
     return new QingStorResource2(normalizeQingStorConfig(config));
   },
   postgres: async (config) => {
-    const { PostgresResource: PostgresResource2 } = await import("./postgres-JNFMPAO2.js");
+    const { PostgresResource: PostgresResource2 } = await import("./postgres-P36Z2YN4.js");
     const { normalizePostgresConfig } = await import("@struktoai/mirage-core");
     return new PostgresResource2(normalizePostgresConfig(config));
   },
   mongodb: async (config) => {
-    const { MongoDBResource: MongoDBResource2 } = await import("./mongodb-ZOX4FRHJ.js");
+    const { MongoDBResource: MongoDBResource2 } = await import("./mongodb-JVR62OIO.js");
     const { normalizeMongoDBConfig } = await import("@struktoai/mirage-core");
     return new MongoDBResource2(normalizeMongoDBConfig(config));
   },
   slack: async (config) => {
-    const { SlackResource: SlackResource2 } = await import("./slack-FVBXY7KD.js");
+    const { SlackResource: SlackResource2 } = await import("./slack-YPS7PII3.js");
     const { normalizeSlackConfig: normalizeSlackConfig2 } = await import("./config-ZV6G2ZEC.js");
     return new SlackResource2(normalizeSlackConfig2(config));
   },
   ssh: async (config) => {
-    const { SSHResource: SSHResource2 } = await import("./ssh-GCXETJ3Z.js");
+    const { SSHResource: SSHResource2 } = await import("./ssh-YFP3SMTJ.js");
     const { normalizeSshConfig: normalizeSshConfig2 } = await import("./config-KJOLGVB2.js");
     return new SSHResource2(normalizeSshConfig2(config));
   },
   discord: async (config) => {
-    const { DiscordResource: DiscordResource2 } = await import("./discord-SAV2RBJV.js");
+    const { DiscordResource: DiscordResource2 } = await import("./discord-BG7OSRJG.js");
     const { normalizeDiscordConfig: normalizeDiscordConfig2 } = await import("./config-DG65OEG3.js");
     return new DiscordResource2(normalizeDiscordConfig2(config));
   },
   trello: async (config) => {
-    const { TrelloResource: TrelloResource2 } = await import("./trello-CQ53BQUL.js");
+    const { TrelloResource: TrelloResource2 } = await import("./trello-XYKWZD6P.js");
     const { normalizeTrelloConfig: normalizeTrelloConfig2 } = await import("./config-GVH27UPE.js");
     return new TrelloResource2(normalizeTrelloConfig2(config));
   },
   linear: async (config) => {
-    const { LinearResource: LinearResource2 } = await import("./linear-2MM55KBC.js");
+    const { LinearResource: LinearResource2 } = await import("./linear-IC37LZV7.js");
     const { normalizeLinearConfig: normalizeLinearConfig2 } = await import("./config-GCQK6NJY.js");
     return new LinearResource2(normalizeLinearConfig2(config));
   },
   notion: async (config) => {
-    const { NotionResource: NotionResource2 } = await import("./notion-UK4GTMT4.js");
+    const { NotionResource: NotionResource2 } = await import("./notion-HKRPQMJS.js");
     const { normalizeNotionConfig: normalizeNotionConfig2 } = await import("./config-IJJXGLBQ.js");
     return new NotionResource2(normalizeNotionConfig2(config));
   },
   langfuse: async (config) => {
-    const { LangfuseResource: LangfuseResource2 } = await import("./langfuse-HUAYVPHF.js");
+    const { LangfuseResource: LangfuseResource2 } = await import("./langfuse-ACASJZ7O.js");
     const { normalizeLangfuseConfig: normalizeLangfuseConfig2 } = await import("./config-LHFFXVYI.js");
     return new LangfuseResource2(normalizeLangfuseConfig2(config));
   },
   github: async (config) => {
-    const { GitHubResource: GitHubResource2 } = await import("./github-KBHWANKQ.js");
+    const { GitHubResource: GitHubResource2 } = await import("./github-DV7E6OFV.js");
     const { normalizeGitHubConfig: normalizeGitHubConfig2 } = await import("./config-3BBWD5AB.js");
     return GitHubResource2.create(normalizeGitHubConfig2(config));
   },
   github_ci: async (config) => {
-    const { GitHubCIResource: GitHubCIResource2 } = await import("./github_ci-HPITNK37.js");
+    const { GitHubCIResource: GitHubCIResource2 } = await import("./github_ci-Q554V5PA.js");
     const { normalizeGitHubCIConfig: normalizeGitHubCIConfig2 } = await import("./config-EIHSP5DZ.js");
     return new GitHubCIResource2(normalizeGitHubCIConfig2(config));
   },
   gdocs: async (config) => {
-    const { GDocsResource: GDocsResource2 } = await import("./gdocs-X5Y2SIQX.js");
+    const { GDocsResource: GDocsResource2 } = await import("./gdocs-R67TDPON.js");
     const { normalizeGDocsConfig: normalizeGDocsConfig2 } = await import("./config-D3RLSPNF.js");
     return new GDocsResource2(normalizeGDocsConfig2(config));
   },
   gsheets: async (config) => {
-    const { GSheetsResource: GSheetsResource2 } = await import("./gsheets-ZSUDIWGK.js");
+    const { GSheetsResource: GSheetsResource2 } = await import("./gsheets-H4RYMQJ5.js");
     const { normalizeGSheetsConfig: normalizeGSheetsConfig2 } = await import("./config-OT2TQQCN.js");
     return new GSheetsResource2(normalizeGSheetsConfig2(config));
   },
   gslides: async (config) => {
-    const { GSlidesResource: GSlidesResource2 } = await import("./gslides-GYXM7IMJ.js");
+    const { GSlidesResource: GSlidesResource2 } = await import("./gslides-YLCHKJOM.js");
     const { normalizeGSlidesConfig: normalizeGSlidesConfig2 } = await import("./config-IDZMEW73.js");
     return new GSlidesResource2(normalizeGSlidesConfig2(config));
   },
   gdrive: async (config) => {
-    const { GDriveResource: GDriveResource2 } = await import("./gdrive-SIQPRIGI.js");
+    const { GDriveResource: GDriveResource2 } = await import("./gdrive-PRN2ALRK.js");
     const { normalizeGDriveConfig: normalizeGDriveConfig2 } = await import("./config-HXVYIXP5.js");
     return new GDriveResource2(normalizeGDriveConfig2(config));
   },
   dropbox: async (config) => {
-    const { DropboxResource: DropboxResource2 } = await import("./dropbox-CQ7MTYX2.js");
+    const { DropboxResource: DropboxResource2 } = await import("./dropbox-74GYLV3R.js");
     const { normalizeDropboxConfig: normalizeDropboxConfig2 } = await import("./config-4UDVSUQJ.js");
     return new DropboxResource2(normalizeDropboxConfig2(config));
   },
   box: async (config) => {
-    const { BoxResource: BoxResource2 } = await import("./box-UXTCAFOZ.js");
+    const { BoxResource: BoxResource2 } = await import("./box-GQ2U2R6R.js");
     const { normalizeBoxConfig: normalizeBoxConfig2 } = await import("./config-CMDBAPDH.js");
     return new BoxResource2(normalizeBoxConfig2(config));
   },
   gmail: async (config) => {
-    const { GmailResource: GmailResource2 } = await import("./gmail-DKHAGJNX.js");
+    const { GmailResource: GmailResource2 } = await import("./gmail-OLN2LT4O.js");
     const { normalizeGmailConfig } = await import("./config-NV5WXP64.js");
     return new GmailResource2(normalizeGmailConfig(config));
   },
   email: async (config) => {
-    const { EmailResource: EmailResource2 } = await import("./email-KBQ7CXS7.js");
+    const { EmailResource: EmailResource2 } = await import("./email-5IZ7OBQ4.js");
     const { normalizeEmailConfig: normalizeEmailConfig2 } = await import("./config-3IVQJBNW.js");
     return new EmailResource2(normalizeEmailConfig2(config));
   }
@@ -1781,6 +2066,7 @@ export {
   DatabricksVolumeResource,
   DigitalOceanResource,
   DiscordResource,
+  DiskObserverStore,
   DiskResource,
   DropboxResource,
   EMAIL_COMMANDS,
@@ -1826,6 +2112,7 @@ export {
   MirageFS,
   MongoDBResource,
   MongoDBStore,
+  Mount,
   NotionResource,
   OCIResource,
   OCI_PROMPT,
@@ -1840,6 +2127,7 @@ export {
   REDIS_PROMPT,
   RedisAccessor,
   RedisFileCacheStore,
+  RedisObserverStore,
   RedisResource,
   RedisStore,
   S3Resource,