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

package/dist/index.js

@@ -1,6 +1,20 @@
+import {
+  DropboxResource
+} from "./chunk-HWQPEBID.js";
+import {
+  BoxResource
+} from "./chunk-BWLUBJQG.js";
+import {
+  normalizeBoxConfig,
+  redactBoxConfig
+} from "./chunk-XFSEADPC.js";
 import {
   GmailResource
-} from "./chunk-HEHERHQ5.js";
+} from "./chunk-CB76WPUS.js";
+import {
+  normalizeGoogleConfig,
+  redactGoogleConfig
+} from "./chunk-LPDLPRPS.js";
 import {
   EMAIL_COMMANDS,
   EMAIL_OPS,
@@ -8,273 +22,277 @@ import {
   EMAIL_WRITE_PROMPT,
   EmailAccessor,
   EmailResource
-} from "./chunk-DTAY7LPC.js";
+} from "./chunk-4GYB7DGC.js";
 import {
   buildEmailConfig,
   normalizeEmailConfig,
   redactEmailConfig
-} from "./chunk-B2ZOKNN4.js";
+} from "./chunk-CQCTCW4S.js";
+import {
+  GDocsResource
+} from "./chunk-JEBH5APX.js";
+import {
+  GSheetsResource
+} from "./chunk-SAOQW6ZJ.js";
+import {
+  normalizeGSheetsConfig,
+  redactGSheetsConfig
+} from "./chunk-D3U7VQCG.js";
 import {
   GSlidesResource
-} from "./chunk-E7RW3SBV.js";
+} from "./chunk-YRJICL2Q.js";
+import {
+  normalizeGSlidesConfig,
+  redactGSlidesConfig
+} from "./chunk-GTAS3QVC.js";
 import {
   GDriveResource
-} from "./chunk-TRTUHCS4.js";
+} from "./chunk-VLRSOWHP.js";
 import {
   normalizeGDriveConfig,
   redactGDriveConfig
-} from "./chunk-DP2PP5V2.js";
-import {
-  DropboxResource
-} from "./chunk-5YOCVEUB.js";
+} from "./chunk-KGC2OGXI.js";
 import {
   normalizeDropboxConfig,
   redactDropboxConfig
-} from "./chunk-Q2IAILVC.js";
+} from "./chunk-HSD24IP2.js";
 import {
-  BoxResource
-} from "./chunk-A4Z6DZ22.js";
+  NotionResource
+} from "./chunk-SI4GMRXD.js";
 import {
-  normalizeBoxConfig,
-  redactBoxConfig
-} from "./chunk-OZAEWZZ3.js";
+  LangfuseResource
+} from "./chunk-M6E7VK4D.js";
 import {
-  normalizeGoogleConfig,
-  redactGoogleConfig
-} from "./chunk-54NTYJEO.js";
+  normalizeLangfuseConfig,
+  redactLangfuseConfig
+} from "./chunk-AULFV3KY.js";
 import {
   GitHubResource
-} from "./chunk-YPT4JBUY.js";
+} from "./chunk-5YRWF5RP.js";
+import {
+  normalizeGitHubConfig,
+  redactGitHubConfig
+} from "./chunk-XUUSWR4U.js";
 import {
   GitHubCIResource
-} from "./chunk-ABTEGAFB.js";
+} from "./chunk-JBDFYIN2.js";
 import {
   normalizeGitHubCIConfig,
   redactGitHubCIConfig
-} from "./chunk-H3I2KZIY.js";
-import {
-  GDocsResource
-} from "./chunk-A7X4L4JM.js";
+} from "./chunk-ZPB3SLPK.js";
 import {
   normalizeGDocsConfig,
   redactGDocsConfig
-} from "./chunk-H3BST2LI.js";
+} from "./chunk-JHI2PHHD.js";
 import {
-  GSheetsResource
-} from "./chunk-XRU5WXZX.js";
+  NEXTCLOUD_COMMANDS,
+  NEXTCLOUD_OPS,
+  NEXTCLOUD_PROMPT,
+  NextcloudAccessor,
+  NextcloudResource
+} from "./chunk-ZPZQXHW2.js";
 import {
-  normalizeGSheetsConfig,
-  redactGSheetsConfig
-} from "./chunk-LW25LMIH.js";
+  DiscordResource
+} from "./chunk-RHUEV4I7.js";
 import {
-  normalizeGSlidesConfig,
-  redactGSlidesConfig
-} from "./chunk-W7FLHT65.js";
+  normalizeDiscordConfig,
+  redactDiscordConfig
+} from "./chunk-EVK6HH6Z.js";
 import {
   TrelloResource
-} from "./chunk-ERELJ7BS.js";
+} from "./chunk-3JZN3GYO.js";
+import {
+  normalizeTrelloConfig,
+  redactTrelloConfig
+} from "./chunk-NJ42VNXG.js";
 import {
   LinearResource
-} from "./chunk-YAVGCQUP.js";
+} from "./chunk-ZMREYTHA.js";
 import {
   normalizeLinearConfig,
   redactLinearConfig
-} from "./chunk-YUK3X3B4.js";
-import {
-  NotionResource
-} from "./chunk-CASCUFK2.js";
+} from "./chunk-IKJQOYI4.js";
 import {
   normalizeNotionConfig,
   redactNotionConfig
-} from "./chunk-JZT4QGIP.js";
+} from "./chunk-VIICUPWQ.js";
 import {
-  LangfuseResource
-} from "./chunk-5DLOHQJ2.js";
-import {
-  normalizeLangfuseConfig,
-  redactLangfuseConfig
-} from "./chunk-VGLHY6BK.js";
+  QINGSTOR_PROMPT,
+  QingStorResource
+} from "./chunk-5I7Q7RHW.js";
 import {
-  normalizeGitHubConfig,
-  redactGitHubConfig
-} from "./chunk-TWGVQLG2.js";
+  PostgresResource,
+  PostgresStore
+} from "./chunk-VHED2STW.js";
 import {
   MongoDBResource,
   MongoDBStore
-} from "./chunk-RLGWMJD3.js";
+} from "./chunk-FRGTDZQT.js";
 import {
   SlackResource
-} from "./chunk-C6NHEDHY.js";
+} from "./chunk-IEVLWEBO.js";
 import {
   normalizeSlackConfig,
   redactSlackConfig
-} from "./chunk-SFUCUARB.js";
+} from "./chunk-IEHPTILN.js";
 import {
   SSHAccessor,
   SSHResource,
   SSH_COMMANDS,
   SSH_OPS,
   SSH_PROMPT
-} from "./chunk-5HCVKTP3.js";
+} from "./chunk-5ZHNPNDD.js";
 import {
   normalizeSshConfig,
   redactSshConfig
-} from "./chunk-UGK4TAVK.js";
+} from "./chunk-LPLZLSMK.js";
 import {
-  DiscordResource
-} from "./chunk-LYDMMNL2.js";
+  normalizeNextcloudConfig,
+  redactNextcloudConfig
+} from "./chunk-MRXTUFBZ.js";
 import {
-  normalizeDiscordConfig,
-  redactDiscordConfig
-} from "./chunk-DNBAMB5J.js";
-import {
-  normalizeTrelloConfig,
-  redactTrelloConfig
-} from "./chunk-RO5IQEDQ.js";
+  DIGITALOCEAN_PROMPT,
+  DigitalOceanResource
+} from "./chunk-CXQGMFI7.js";
 import {
   TENCENT_PROMPT,
   TencentResource
-} from "./chunk-L6JPBJAS.js";
+} from "./chunk-EGZNOUMH.js";
+import {
+  redactTencentConfig,
+  resolvedTencentEndpoint
+} from "./chunk-WTSSEUOZ.js";
 import {
   ALIYUN_PROMPT,
   AliyunResource
-} from "./chunk-KTNDT45N.js";
+} from "./chunk-XEMLYWHK.js";
 import {
   redactAliyunConfig,
   resolvedAliyunEndpoint
-} from "./chunk-NJMGCT63.js";
+} from "./chunk-2QNPKPZZ.js";
 import {
   SCALEWAY_PROMPT,
   ScalewayResource
-} from "./chunk-FXFDBF3P.js";
+} from "./chunk-L4GMDSMB.js";
 import {
   redactScalewayConfig,
   resolvedScalewayEndpoint
-} from "./chunk-XLQI4IT2.js";
-import {
-  QINGSTOR_PROMPT,
-  QingStorResource
-} from "./chunk-3IJSIVKT.js";
+} from "./chunk-YBVMZ7SR.js";
 import {
   redactQingStorConfig,
   resolvedQingStorEndpoint
-} from "./chunk-OHROA3FQ.js";
+} from "./chunk-WWP2STF5.js";
 import {
-  PostgresResource,
-  PostgresStore
-} from "./chunk-NHS7WLEQ.js";
+  SEAWEEDFS_PROMPT,
+  SeaweedFSResource
+} from "./chunk-NLXJMXVE.js";
 import {
   CEPH_PROMPT,
   CephResource
-} from "./chunk-C6NHFMIP.js";
+} from "./chunk-XADEMW6B.js";
+import {
+  redactCephConfig
+} from "./chunk-UYA3XL3J.js";
 import {
   WASABI_PROMPT,
   WasabiResource
-} from "./chunk-O7ODGJYL.js";
+} from "./chunk-L7FEZ7LU.js";
 import {
   redactWasabiConfig,
   resolvedWasabiEndpoint
-} from "./chunk-JALIYI6M.js";
+} from "./chunk-S4KVLPBR.js";
 import {
   BACKBLAZE_PROMPT,
   BackblazeResource
-} from "./chunk-HQ4KWN76.js";
+} from "./chunk-SYMNWNC3.js";
 import {
   redactBackblazeConfig,
   resolvedBackblazeEndpoint
-} from "./chunk-XHCBHYN4.js";
-import {
-  DIGITALOCEAN_PROMPT,
-  DigitalOceanResource
-} from "./chunk-AJICZLHT.js";
+} from "./chunk-UAJYJP5C.js";
 import {
   redactDigitalOceanConfig,
   resolvedDigitalOceanEndpoint
-} from "./chunk-ZNWVJ6UW.js";
+} from "./chunk-3ASOQTZB.js";
 import {
-  redactTencentConfig,
-  resolvedTencentEndpoint
-} from "./chunk-YGZMVNN5.js";
+  HF_BUCKETS_PROMPT,
+  HfBucketsResource
+} from "./chunk-4M73WHIE.js";
 import {
   HF_DATASETS_PROMPT,
   HfDatasetsResource
-} from "./chunk-RQYEEA2O.js";
+} from "./chunk-DXU7NZPH.js";
 import {
   HF_MODELS_PROMPT,
   HfModelsResource
-} from "./chunk-WL7HS7EM.js";
+} from "./chunk-V7JVMG63.js";
 import {
   HF_SPACES_PROMPT,
   HfSpacesResource
-} from "./chunk-OYV2DN66.js";
+} from "./chunk-BWWU5T2D.js";
+import {
+  HF_COMMANDS,
+  HF_OPS,
+  HF_RESOURCES,
+  HfAccessor,
+  HfBucketsAccessor,
+  HfDatasetsAccessor,
+  HfModelsAccessor,
+  HfSpacesAccessor
+} from "./chunk-HEDE2377.js";
+import {
+  HF_ENDPOINT,
+  assertHfRepoId,
+  normalizeHfBucketsConfig,
+  normalizeHfRepoConfig,
+  redactHfBucketsConfig,
+  redactHfRepoConfig
+} from "./chunk-KAWDDS27.js";
 import {
   MINIO_PROMPT,
   MinIOResource
-} from "./chunk-Q6CDMOM6.js";
+} from "./chunk-4X6CLF4F.js";
 import {
   redactMinIOConfig
-} from "./chunk-DYXEITK3.js";
-import {
-  SEAWEEDFS_PROMPT,
-  SeaweedFSResource
-} from "./chunk-3T3RMDNX.js";
+} from "./chunk-GF75O2EN.js";
 import {
   redactSeaweedFSConfig
-} from "./chunk-2CC5VW7K.js";
+} from "./chunk-MIQ3ECZM.js";
 import {
-  redactCephConfig
-} from "./chunk-OPYQ5KIO.js";
+  GCSResource,
+  GCS_PROMPT
+} from "./chunk-25W4XQJZ.js";
+import {
+  GCS_ENDPOINT,
+  redactGcsConfig
+} from "./chunk-E3KXVEYI.js";
 import {
   OCIResource,
   OCI_PROMPT
-} from "./chunk-PJBQKMCD.js";
+} from "./chunk-TUNR4VUM.js";
 import {
   redactOciConfig
-} from "./chunk-RQK5UPMP.js";
+} from "./chunk-H62XQZUM.js";
 import {
   R2Resource,
   R2_PROMPT
-} from "./chunk-B6SXRCBO.js";
+} from "./chunk-ZM44MGC5.js";
 import {
   redactR2Config
-} from "./chunk-LAJJPLEV.js";
+} from "./chunk-VBYIDRNU.js";
 import {
   SUPABASE_PROMPT,
   SupabaseResource
-} from "./chunk-BYTU2YC3.js";
+} from "./chunk-F5NWRF32.js";
 import {
   redactSupabaseConfig,
   resolvedSupabaseEndpoint
-} from "./chunk-QGRDPSAH.js";
-import {
-  HF_BUCKETS_PROMPT,
-  HfBucketsResource
-} from "./chunk-G5BZE7UA.js";
-import {
-  HF_COMMANDS,
-  HF_OPS,
-  HF_RESOURCES,
-  HfAccessor,
-  HfBucketsAccessor,
-  HfDatasetsAccessor,
-  HfModelsAccessor,
-  HfSpacesAccessor
-} from "./chunk-WSGEIVY3.js";
-import {
-  HF_ENDPOINT,
-  assertHfRepoId,
-  normalizeHfBucketsConfig,
-  normalizeHfRepoConfig,
-  redactHfBucketsConfig,
-  redactHfRepoConfig
-} from "./chunk-EGB7V74Z.js";
+} from "./chunk-2ERLWAGG.js";
 import {
   DISK_COMMANDS,
   DISK_OPS,
   DISK_PROMPT,
   DiskResource
-} from "./chunk-PBBG7VFT.js";
-import "./chunk-U6QSXTUS.js";
+} from "./chunk-W5ZLIQFR.js";
 import {
   REDIS_COMMANDS,
   REDIS_OPS,
@@ -283,43 +301,42 @@ import {
   RedisResource,
   RedisStore,
   stat
-} from "./chunk-N72CAZEH.js";
+} from "./chunk-OSVZKYXS.js";
 import {
-  loadOptionalPeer
-} from "./chunk-E2ISWXLB.js";
+  S3Resource
+} from "./chunk-IUXXZHY3.js";
 import {
-  DatabricksVolumeResource,
-  loadDatabricksProfile,
-  parseDatabricksCfg
-} from "./chunk-JZQHKDSY.js";
+  redactConfig
+} from "./chunk-HCU3B6FW.js";
 import {
-  GCSResource,
-  GCS_PROMPT
-} from "./chunk-IQVNVTOP.js";
+  GridFSAccessor,
+  GridFSResource
+} from "./chunk-CGGO5NKD.js";
 import {
-  S3Resource
-} from "./chunk-MHCMHKM6.js";
+  loadOptionalPeer
+} from "./chunk-OQKNDS66.js";
 import {
-  redactConfig
-} from "./chunk-UT2OPSN4.js";
+  normalizeGridFSConfig
+} from "./chunk-C7TNKIK5.js";
 import {
-  GCS_ENDPOINT,
-  redactGcsConfig
-} from "./chunk-XGJ2QERC.js";
+  DatabricksVolumeResource,
+  loadDatabricksProfile,
+  parseDatabricksCfg
+} from "./chunk-HGIPWY5Y.js";
 
 // src/index.ts
 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";
@@ -328,7 +345,14 @@ import { tmpdir } from "os";
 import { join } from "path";
 
 // src/fuse/fs.ts
-import { FileType, rstripSlash } from "@struktoai/mirage-core";
+import { posix } from "path";
+import {
+  FileType,
+  isMissingOp,
+  PathSpec,
+  runWithSession,
+  rstripSlash
+} from "@struktoai/mirage-core";
 
 // src/fuse/platform/macos.ts
 var MACOS_METADATA = /* @__PURE__ */ new Set([
@@ -342,17 +366,15 @@ function isMacosMetadata(name) {
 }
 
 // src/fuse/fs.ts
-var ENV_AGENT_ID = "MIRAGE_AGENT_ID";
-var MIRAGE_DIR = "/.mirage";
-var MIRAGE_WHOAMI = "/.mirage/whoami";
 var ENOENT = -2;
 var EACCES = -13;
 var ENOTDIR = -20;
 var EEXIST = -17;
 var ENOTEMPTY = -66;
 var EIO = -5;
+var EINVAL = -22;
+var EROFS = -30;
 var PREFETCH_TTL_MS = 3e4;
-var UNKNOWN_SIZE_SENTINEL = 100 * 1024 * 1024;
 function classifyError(err) {
   const code = err.code;
   if (code === "ENOTEMPTY") return ENOTEMPTY;
@@ -363,6 +385,7 @@ function classifyError(err) {
   const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
   if (msg.includes("not empty") || msg.includes("enotempty")) return ENOTEMPTY;
   if (msg.includes("not a directory") || msg.includes("enotdir")) return ENOTDIR;
+  if (msg.includes("not allowed to access mount")) return EACCES;
   if (msg.includes("permission") || msg.includes("eacces") || msg.includes("read-only"))
     return EACCES;
   if (msg.includes("file exists") || msg.includes("eexist")) return EEXIST;
@@ -372,33 +395,32 @@ function classifyError(err) {
 }
 var MirageFS = class {
   ws;
-  agentId;
   now;
   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;
   uid;
   gid;
+  session;
   constructor(ws, options = {}) {
     this.ws = ws;
-    this.agentId = options.agentId ?? process.env[ENV_AGENT_ID] ?? `agent-${Math.random().toString(36).slice(2, 10)}`;
     this.now = /* @__PURE__ */ new Date();
     this.root = options.rootPrefix !== void 0 ? rstripSlash(options.rootPrefix) : "";
     this.prefixes = this.root === "" ? ws.mounts().map((m) => m.prefix) : [];
     this.uid = typeof process.getuid === "function" ? process.getuid() : 0;
     this.gid = typeof process.getgid === "function" ? process.getgid() : 0;
+    this.session = options.session ?? null;
   }
   // ── helpers ──────────────────────────────────────────────────────
-  resolve(path) {
-    if (this.root === "") return path;
-    return path === "/" ? this.root : this.root + path;
-  }
-  whoamiContent() {
-    const lines = [`agent: ${this.agentId}`, "cwd: /", `mounts: ${this.prefixes.join(", ")}`];
-    return new TextEncoder().encode(lines.join("\n") + "\n");
+  resolve(path4) {
+    if (this.root === "") return path4;
+    return path4 === "/" ? this.root : this.root + path4;
   }
   dirStat() {
     return {
@@ -424,8 +446,62 @@ var MirageFS = class {
       gid: this.gid
     };
   }
-  isVirtualDir(path) {
-    const bare = rstripSlash(path);
+  /**
+   * Fold merged stat attributes into a FUSE attr. The workspace stat
+   * already carries the namespace overlay (chmod bits, chown ids, touched
+   * mtime), so honoring these fields here is what makes metadata ops
+   * visible over FUSE. String uid/gid (names) are skipped: FUSE wants
+   * numeric ids and there is no user db to map against.
+   */
+  applyStatAttrs(entry, s) {
+    if (s.mode !== null) {
+      entry.mode = entry.mode & ~4095 | s.mode & 4095;
+    }
+    if (typeof s.uid === "number") entry.uid = s.uid;
+    if (typeof s.gid === "number") entry.gid = s.gid;
+    if (s.modified !== null) {
+      const ts = new Date(s.modified);
+      if (!Number.isNaN(ts.getTime())) {
+        entry.mtime = ts;
+        entry.ctime = ts;
+      }
+    }
+    return entry;
+  }
+  /**
+   * The target to present for a namespace link at a FUSE path, or null
+   * when not a link. Relative targets are stored verbatim and returned
+   * as-is. Absolute targets name virtual paths, so they are rewritten
+   * relative to the link's directory: returned raw, the kernel would
+   * resolve them against the host root and escape the mountpoint.
+   */
+  linkTarget(path4) {
+    const links = this.ws.fs.links;
+    if (links === null) return null;
+    const target = links.readlink(this.resolve(path4));
+    if (target === null) return null;
+    if (!target.startsWith("/")) return target;
+    let fuseTarget = target;
+    if (this.root !== "") {
+      if (target === this.root) {
+        fuseTarget = "/";
+      } else if (target.startsWith(this.root + "/")) {
+        fuseTarget = target.slice(this.root.length);
+      } else {
+        return target;
+      }
+    }
+    const slash = path4.lastIndexOf("/");
+    const parent = slash <= 0 ? "/" : path4.slice(0, slash);
+    return posix.relative(parent, fuseTarget);
+  }
+  linkStat(target) {
+    const entry = this.fileStat(new TextEncoder().encode(target).byteLength);
+    entry.mode = 41471;
+    return entry;
+  }
+  isVirtualDir(path4) {
+    const bare = rstripSlash(path4);
     const normalized = bare + "/";
     for (const p of this.prefixes) {
       const pBare = rstripSlash(p);
@@ -433,8 +509,8 @@ var MirageFS = class {
     }
     return false;
   }
-  virtualChildren(path) {
-    const normalized = path === "/" ? "/" : rstripSlash(path) + "/";
+  virtualChildren(path4) {
+    const normalized = path4 === "/" ? "/" : rstripSlash(path4) + "/";
     const children = /* @__PURE__ */ new Set();
     for (const p of this.prefixes) {
       if (p.startsWith(normalized) && p !== normalized) {
@@ -445,47 +521,47 @@ var MirageFS = class {
     }
     return [...children].sort();
   }
-  cachedSize(path) {
+  cachedSize(path4) {
     for (const ctx of this.handles.values()) {
-      if (ctx.path === path && ctx.data !== void 0) return ctx.data.byteLength;
+      if (ctx.path === path4 && ctx.data !== void 0) return ctx.data.byteLength;
     }
-    const entry = this.prefetchCache.get(path);
+    const entry = this.prefetchCache.get(path4);
     if (entry !== void 0 && entry.expires > Date.now()) return entry.data.byteLength;
     return null;
   }
-  cachedData(path) {
+  cachedData(path4) {
     for (const ctx of this.handles.values()) {
-      if (ctx.path === path && ctx.data !== void 0) return ctx.data;
+      if (ctx.path === path4 && ctx.data !== void 0) return ctx.data;
     }
-    const entry = this.prefetchCache.get(path);
+    const entry = this.prefetchCache.get(path4);
     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(path4);
     return null;
   }
   /**
-   * Fetch bytes for a size-unknown file and cache them so the immediate
-   * getattr → open → read burst (and subsequent stats within the TTL) reuse
-   * the same fetch. Required because @zkochan/fuse-native doesn't expose
-   * libfuse's `direct_io` flag — without a real size from getattr, the kernel
-   * decides the file is empty and never issues read().
+   * Fetch bytes for a size-unknown file and cache them so the open → read →
+   * fstat burst (and subsequent stats within the TTL) reuse the same fetch.
+   * With getattr reporting 0 pre-open, this hydration is what lets fgetattr
+   * answer with the real byte length after open (mirrors Python's
+   * `_prefetch_read`).
    */
-  async prefetch(path) {
-    const cached = this.cachedData(path);
+  async prefetch(path4) {
+    const cached = this.cachedData(path4);
     if (cached !== null) return cached;
-    const inflight = this.prefetchInflight.get(path);
+    const inflight = this.prefetchInflight.get(path4);
     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(path4));
+        this.prefetchCache.set(path4, { data, expires: Date.now() + PREFETCH_TTL_MS });
         return data;
       } catch {
         return null;
       } finally {
-        this.prefetchInflight.delete(path);
+        this.prefetchInflight.delete(path4);
       }
     })();
-    this.prefetchInflight.set(path, promise);
+    this.prefetchInflight.set(path4, promise);
     return promise;
   }
   /** Drain and return accumulated op records (mirrors Python's drain_ops). */
@@ -494,12 +570,12 @@ 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(path4, data) {
+    await this.ws.dispatch("write", this.resolve(path4), [data]);
   }
   // ── FUSE op surface (mirrors mfusepy Operations) ─────────────────
   ops() {
-    return {
+    const table = {
       readdir: this.readdir.bind(this),
       getattr: this.getattr.bind(this),
       fgetattr: this.fgetattr.bind(this),
@@ -507,6 +583,8 @@ var MirageFS = class {
       read: this.read.bind(this),
       write: this.write.bind(this),
       create: this.create.bind(this),
+      readlink: this.readlink.bind(this),
+      symlink: this.symlink.bind(this),
       unlink: this.unlink.bind(this),
       mkdir: this.mkdir.bind(this),
       rmdir: this.rmdir.bind(this),
@@ -519,60 +597,78 @@ 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)
     };
+    const session = this.session;
+    if (session === null) return table;
+    const bound = {};
+    for (const [name, fn] of Object.entries(table)) {
+      bound[name] = (...args) => {
+        void runWithSession(session, () => {
+          fn(...args);
+          return Promise.resolve();
+        });
+      };
+    }
+    return bound;
   }
-  getattr(path, cb) {
+  getattr(path4, cb) {
     void (async () => {
-      if (path === "/" || path === MIRAGE_DIR) {
+      if (path4 === "/") {
         cb(0, this.dirStat());
         return;
       }
-      if (path === MIRAGE_WHOAMI) {
-        cb(0, this.fileStat(this.whoamiContent().byteLength));
-        return;
-      }
-      const name = path.slice(path.lastIndexOf("/") + 1);
+      const name = path4.slice(path4.lastIndexOf("/") + 1);
       if (isMacosMetadata(name)) {
         cb(ENOENT);
         return;
       }
-      if (this.isVirtualDir(path)) {
+      const target = this.linkTarget(path4);
+      if (target !== null) {
+        cb(0, this.linkStat(target));
+        return;
+      }
+      if (this.isVirtualDir(path4)) {
         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(path4));
         if (s.type === FileType.DIRECTORY) {
-          cb(0, this.dirStat());
+          cb(0, this.applyStatAttrs(this.dirStat(), s));
           return;
         }
         let size = s.size;
-        size ??= this.cachedSize(path) ?? UNKNOWN_SIZE_SENTINEL;
-        cb(0, this.fileStat(size));
+        size ??= this.cachedSize(path4) ?? 0;
+        cb(0, this.applyStatAttrs(this.fileStat(size), s));
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  fgetattr(path, fd, cb) {
+  fgetattr(path4, 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(path4, cb);
   }
-  readdir(path, cb) {
+  readdir(path4, cb) {
     void (async () => {
-      if (path === MIRAGE_DIR) {
-        cb(0, [".", "..", "whoami"]);
-        return;
+      const names = new Set(this.virtualChildren(path4));
+      const links = this.ws.fs.links;
+      if (links !== null) {
+        for (const linkName of links.linksUnder(this.resolve(path4)).keys()) {
+          if (linkName !== "" && !isMacosMetadata(linkName)) names.add(linkName);
+        }
       }
-      const names = new Set(this.virtualChildren(path));
-      if (path === "/") names.add(".mirage");
       try {
-        const entries = await this.ws.fs.readdir(this.resolve(path));
+        const entries = await this.ws.fs.readdir(this.resolve(path4));
         for (const e of entries) {
           const part = rstripSlash(e).split("/").pop() ?? "";
           if (part !== "" && !isMacosMetadata(part)) names.add(part);
@@ -586,22 +682,15 @@ var MirageFS = class {
       cb(0, [".", "..", ...[...names].sort()]);
     })();
   }
-  read(path, fd, buf, len, pos, cb) {
+  read(path4, fd, buf, len, pos, cb) {
     void (async () => {
-      if (path === MIRAGE_WHOAMI) {
-        const data = this.whoamiContent();
-        const slice = data.subarray(pos, pos + len);
-        buf.set(slice, 0);
-        cb(slice.byteLength);
-        return;
-      }
       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(path4);
+          ctx.data = cached ?? await this.ws.fs.readFile(this.resolve(path4));
         }
-        const data = ctx?.data ?? this.cachedData(path) ?? await this.ws.fs.readFile(this.resolve(path));
+        const data = ctx?.data ?? this.cachedData(path4) ?? await this.ws.fs.readFile(this.resolve(path4));
         const slice = data.subarray(pos, pos + len);
         buf.set(slice, 0);
         cb(slice.byteLength);
@@ -610,7 +699,7 @@ var MirageFS = class {
       }
     })();
   }
-  write(path, fd, buf, len, pos, cb) {
+  write(path4, 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 +712,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(path4), { raw: true });
         } catch {
         }
         let merged = existing;
@@ -642,45 +731,84 @@ var MirageFS = class {
           }
           merged = out;
         }
-        await this.writeFile(path, merged);
+        await this.writeFile(path4, merged);
         cb(len);
       } catch {
         cb(0);
       }
     })();
   }
-  create(path, _mode, cb) {
+  create(path4, _mode, cb) {
     void (async () => {
       try {
         try {
-          await this.ws.dispatch("create", this.resolve(path));
+          await this.ws.dispatch("create", this.resolve(path4));
         } 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));
+          if (!isMissingOp(dispatchErr, "create")) throw dispatchErr;
+          await this.writeFile(path4, new Uint8Array(0));
         }
         const fh = this.nextFh++;
-        this.handles.set(fh, { path });
+        this.handles.set(fh, { path: path4 });
         cb(0, fh);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  mkdir(path, _mode, cb) {
+  mkdir(path4, _mode, cb) {
     void (async () => {
       try {
-        await this.ws.fs.mkdir(this.resolve(path));
+        await this.ws.dispatch("mkdir", this.resolve(path4));
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  unlink(path, cb) {
+  readlink(path4, cb) {
+    const target = this.linkTarget(path4);
+    if (target === null) {
+      cb(EINVAL);
+      return;
+    }
+    cb(0, target);
+  }
+  /**
+   * Create namespace link `dest -> src` (ln -s src dest; libfuse passes
+   * the pointee first). Relative sources are stored verbatim (resolved
+   * at follow time, exactly like the shell `ln -s`); absolute sources
+   * are mapped into virtual space so a scoped mount stores the path it
+   * will later follow.
+   */
+  symlink(src, dest, cb) {
+    void (async () => {
+      const links = this.ws.fs.links;
+      if (links === null) {
+        cb(EROFS);
+        return;
+      }
+      const stored = src.startsWith("/") ? this.resolve(src) : src;
+      try {
+        await links.symlink(this.resolve(dest), stored, Date.now() / 1e3);
+        cb(0);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  unlink(path4, cb) {
     void (async () => {
+      const links = this.ws.fs.links;
+      if (links?.isLink(this.resolve(path4)) === true) {
+        await links.unlink(this.resolve(path4));
+        this.xattrs.delete(path4);
+        this.prefetchCache.delete(path4);
+        cb(0);
+        return;
+      }
       try {
-        await this.ws.fs.unlink(this.resolve(path));
+        await this.ws.dispatch("unlink", this.resolve(path4));
+        this.xattrs.delete(path4);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
@@ -690,43 +818,50 @@ var MirageFS = class {
   rename(src, dst, cb) {
     void (async () => {
       try {
-        await this.ws.fs.rename(this.resolve(src), this.resolve(dst));
+        await this.ws.dispatch("rename", this.resolve(src), [
+          PathSpec.fromStrPath(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(path4, cb) {
     void (async () => {
       try {
         try {
-          const entries = await this.ws.fs.readdir(this.resolve(path));
+          const entries = await this.ws.fs.readdir(this.resolve(path4));
           if (entries.length > 0) {
             cb(ENOTEMPTY);
             return;
           }
         } catch {
         }
-        await this.ws.fs.rmdir(this.resolve(path));
+        await this.ws.dispatch("rmdir", this.resolve(path4));
+        this.xattrs.delete(path4);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  truncate(path, size, cb) {
+  truncate(path4, size, cb) {
     void (async () => {
       try {
         try {
-          await this.ws.dispatch("truncate", this.resolve(path), [size]);
+          await this.ws.dispatch("truncate", this.resolve(path4), [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));
+          if (!isMissingOp(dispatchErr, "truncate")) throw dispatchErr;
+          const data = await this.ws.fs.readFile(this.resolve(path4), { 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(path4, out);
         }
         cb(0);
       } catch (err) {
@@ -750,36 +885,80 @@ 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(path4, _mode, cb) {
+    this.getattrValidate(path4, cb);
+  }
+  chown(path4, _uid, _gid, cb) {
+    this.getattrValidate(path4, cb);
+  }
+  utimens(path4, _atime, _mtime, cb) {
+    this.getattrValidate(path4, cb);
+  }
+  access(path4, _amode, cb) {
+    this.getattrValidate(path4, 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(path4, name, value, _position, _flags, cb) {
+    this.getattr(path4, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      let attrs = this.xattrs.get(path4);
+      if (attrs === void 0) {
+        attrs = /* @__PURE__ */ new Map();
+        this.xattrs.set(path4, attrs);
+      }
+      attrs.set(name, Buffer.from(value));
+      cb(0);
+    });
   }
-  chown(path, _uid, _gid, cb) {
-    this.getattrValidate(path, cb);
+  getxattr(path4, name, _position, cb) {
+    this.getattr(path4, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      cb(0, this.xattrs.get(path4)?.get(name));
+    });
   }
-  utimens(path, _atime, _mtime, cb) {
-    this.getattrValidate(path, cb);
+  listxattr(path4, cb) {
+    this.getattr(path4, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      const attrs = this.xattrs.get(path4);
+      cb(0, attrs ? [...attrs.keys()] : []);
+    });
   }
-  access(path, _amode, cb) {
-    this.getattrValidate(path, cb);
+  removexattr(path4, name, cb) {
+    this.getattr(path4, (code) => {
+      if (code !== 0) {
+        cb(code);
+        return;
+      }
+      this.xattrs.get(path4)?.delete(name);
+      cb(0);
+    });
   }
-  getattrValidate(path, cb) {
-    this.getattr(path, (code) => {
+  getattrValidate(path4, cb) {
+    this.getattr(path4, (code) => {
       cb(code);
     });
   }
-  open(path, _flags, cb) {
+  open(path4, _flags, cb) {
     void (async () => {
-      if (path === MIRAGE_WHOAMI) {
-        const fh = this.nextFh++;
-        this.handles.set(fh, { path });
-        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(path4));
+        const ctx = { path: path4 };
         if (s.size === null && s.type !== FileType.DIRECTORY) {
-          const data = await this.prefetch(path);
+          const data = await this.prefetch(path4);
           if (data !== null) ctx.data = data;
         }
         const fh = this.nextFh++;
@@ -794,7 +973,7 @@ var MirageFS = class {
     this.handles.delete(fd);
     cb(0);
   }
-  flush(path, fd, cb) {
+  flush(path4, fd, cb) {
     const ctx = this.handles.get(fd);
     if (ctx?.writeBuf === void 0 || ctx.writeBuf.length === 0) {
       cb(0);
@@ -806,7 +985,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(path4), { raw: true });
         } catch {
         }
         let total = existing.byteLength;
@@ -818,19 +997,32 @@ var MirageFS = class {
         for (const [off, chunk] of writes) {
           merged.set(chunk, off);
         }
-        await this.writeFile(path, merged);
+        await this.writeFile(path4, merged);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  fsync(path, _datasync, fd, cb) {
-    this.flush(path, fd, cb);
+  fsync(path4, _datasync, fd, cb) {
+    this.flush(path4, fd, cb);
   }
 };
 
 // src/fuse/mount.ts
+function appendDirectIO(fuse) {
+  const orig = fuse._fuseOptions?.bind(fuse);
+  if (orig === void 0) {
+    throw new Error(
+      "@zkochan/fuse-native no longer exposes _fuseOptions(); the direct_io mount option cannot be applied. Update appendDirectIO in mount.ts for the new fuse-native version."
+    );
+  }
+  fuse._fuseOptions = () => {
+    const serialized = orig();
+    if (serialized === "") return "-odirect_io";
+    return serialized.includes("direct_io") ? serialized : `${serialized},direct_io`;
+  };
+}
 async function loadFuse() {
   const mod = await loadOptionalPeer(
     () => import("@zkochan/fuse-native"),
@@ -859,16 +1051,17 @@ 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, {
-    ...agentId !== void 0 ? { agentId } : {},
-    ...options.rootPrefix !== void 0 ? { rootPrefix: options.rootPrefix } : {}
+    ...options.rootPrefix !== void 0 ? { rootPrefix: options.rootPrefix } : {},
+    ...options.session !== void 0 ? { session: options.session } : {}
   });
   const autoUnmount = options.autoUnmount ?? process.platform === "linux";
   const fuseOpts = {
@@ -879,6 +1072,7 @@ async function mount(ws, options = {}) {
     ...options.fuseOptions ?? {}
   };
   const fuse = new Fuse(mountpoint, mfs.ops(), fuseOpts);
+  if (fuseOpts.directIO !== false) appendDirectIO(fuse);
   await new Promise((resolve, reject) => {
     fuse.mount((err) => {
       if (err === null) resolve();
@@ -887,6 +1081,7 @@ async function mount(ws, options = {}) {
   });
   return {
     mountpoint,
+    ownsMountpoint,
     unmount: () => new Promise((resolve, reject) => {
       fuse.unmount((err) => {
         if (err === null) resolve();
@@ -901,6 +1096,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 +1137,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 +1145,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 +1227,35 @@ 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 specs = {};
+    const commandSafeguards = {
+      ...options.commandSafeguards ?? {}
+    };
+    const fuseTargets = [];
+    for (const [prefix, value] of Object.entries(resources)) {
+      if (value instanceof Mount) {
+        specs[prefix] = value.options.mode !== void 0 ? [value.resource, value.options.mode] : value.resource;
+        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 {
+        specs[prefix] = value;
+      }
+    }
+    super(specs, {
       ...options,
+      ...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,45 +1264,865 @@ 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.
+   *
+   * A session-bound mount (`sessionId` given) runs every op under that
+   * session's mount grants (the kernel-tier primitive: bind-mount the tree
+   * into a container and the narrowing travels with it); it is keyed
+   * separately so the same prefix can also be exposed unbound.
+   */
+  async addFuseMount(prefix, mountpoint, sessionId) {
+    const session = sessionId !== void 0 ? this.getSession(sessionId) : void 0;
+    const key = sessionId === void 0 ? prefix : `${prefix}@${sessionId}`;
+    if (mountpoint !== void 0) this.registerFuseMount(key, mountpoint);
+    const fm = new FuseManager();
+    this.fuseManagers.set(key, fm);
+    try {
+      const mp = await fm.setup(this, {
+        rootPrefix: prefix,
+        ...mountpoint !== void 0 ? { mountpoint } : {},
+        ...session !== void 0 ? { session } : {}
+      });
+      if (mountpoint === void 0) this.registerFuseMount(key, mp);
+      return mp;
+    } catch (err) {
+      this.fuseManagers.delete(key);
+      this.fuseMountpointsMap.delete(key);
+      throw err;
+    }
+  }
+  async removeFuseMount(prefix, sessionId) {
+    const key = sessionId === void 0 ? prefix : `${prefix}@${sessionId}`;
+    const fm = this.fuseManagers.get(key);
+    this.fuseManagers.delete(key);
+    if (fm !== void 0) await fm.unmount();
+    this.fuseMountpointsMap.delete(key);
+  }
   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 pending = this.clientPromise;
+    this.clientPromise = null;
+    const c = await pending;
+    await c.quit();
+  }
+};
+
+// src/workspace/namespace/disk.ts
+import { NamespaceStore } from "@struktoai/mirage-core";
+
+// src/workspace/session/disk.ts
+import { mkdir as mkdir2, open, readFile as readFile2, readdir as readdir2, rename, stat as stat2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+import { generationOf, SessionStore } from "@struktoai/mirage-core";
+var LOCK_STALE_SECONDS = 10;
+var LOCK_RETRY_SLEEP_MS = 5;
+var LOCK_RETRY_LIMIT = 2e3;
+var tmpCounter = 0;
+function quoteName(name) {
+  return encodeURIComponent(name).replace(
+    /[!'()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+function isMissing(e) {
+  return e.code === "ENOENT";
+}
+var DiskRecordClient = class {
+  dir;
+  constructor(root, prefix) {
+    this.dir = path2.join(root, prefix);
+  }
+  recordPath(name) {
+    return path2.join(this.dir, `${quoteName(name)}.json`);
+  }
+  // The token slot mirrors the S3 client's ETag but stays empty: disk
+  // CAS anchors on the lockfile, not on a version token.
+  async get(name) {
+    let body;
+    try {
+      body = await readFile2(this.recordPath(name));
+    } catch (e) {
+      if (isMissing(e)) return [null, ""];
+      throw e;
+    }
+    return [JSON.parse(body.toString()), ""];
+  }
+  async put(name, fields) {
+    await mkdir2(this.dir, { recursive: true });
+    await this.writeRecord(this.recordPath(name), fields);
+  }
+  /**
+   * Write one record iff its stored generation matches.
+   *
+   * Take the record's lockfile, re-read under the lock, check the
+   * generation, then tmp-write + rename. Losing the lock race or the
+   * generation check resolves false; the caller adopts and retries.
+   */
+  async casPut(name, fields, expectedGeneration) {
+    await mkdir2(this.dir, { recursive: true });
+    const target = this.recordPath(name);
+    const lockPath = `${target}.lock`;
+    let fh = await this.acquireLock(lockPath);
+    if (fh === null) {
+      if (!await this.reclaimStaleLock(lockPath)) return false;
+      fh = await this.acquireLock(lockPath);
+      if (fh === null) return false;
+    }
+    try {
+      const [stored] = await this.get(name);
+      if (generationOf(stored) !== expectedGeneration) return false;
+      await this.writeRecord(target, fields);
+      return true;
+    } finally {
+      await this.releaseLock(fh, lockPath);
+    }
+  }
+  async listNames() {
+    let entries;
+    try {
+      entries = await readdir2(this.dir);
+    } catch (e) {
+      if (isMissing(e)) return [];
+      throw e;
+    }
+    return entries.filter((n) => n.endsWith(".json")).map((n) => decodeURIComponent(n.slice(0, -".json".length)));
+  }
+  async loadAll() {
+    const names = await this.listNames();
+    const records = await Promise.all(names.map((name) => this.get(name)));
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < names.length; i++) {
+      const name = names[i];
+      const fields = records[i]?.[0];
+      if (name !== void 0 && fields != null) out.set(name, fields);
+    }
+    return out;
+  }
+  async delete(names) {
+    for (const name of names) {
+      try {
+        await unlink2(this.recordPath(name));
+      } catch (e) {
+        if (!isMissing(e)) throw e;
+      }
+    }
+  }
+  async clear() {
+    await this.delete(await this.listNames());
+  }
+  async close() {
+  }
+  /**
+   * Block until this record's lockfile is held; handle to release.
+   *
+   * For callers doing a read-modify-write that is not generation-CAS
+   * (e.g. the single-file namespace plane); spins past contention and
+   * reclaims stale locks, throwing only if a live writer holds the
+   * lock for the whole retry budget (~10s).
+   */
+  async lock(name) {
+    await mkdir2(this.dir, { recursive: true });
+    const lockPath = `${this.recordPath(name)}.lock`;
+    for (let i = 0; i < LOCK_RETRY_LIMIT; i++) {
+      const fh = await this.acquireLock(lockPath);
+      if (fh !== null) return fh;
+      if (await this.reclaimStaleLock(lockPath)) continue;
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_SLEEP_MS));
+    }
+    throw new Error(`could not acquire lock ${lockPath}`);
+  }
+  async unlock(name, fh) {
+    await this.releaseLock(fh, `${this.recordPath(name)}.lock`);
+  }
+  // O_CREAT|O_EXCL ('wx'): filesystem-atomic mutex, the git protocol.
+  // Local filesystems only (O_EXCL is unreliable on ancient NFS, the
+  // same caveat git ships with).
+  async acquireLock(lockPath) {
+    let fh;
+    try {
+      fh = await open(lockPath, "wx");
+    } catch (e) {
+      if (e.code === "EEXIST") return null;
+      throw e;
+    }
+    await fh.write(String(process.pid));
+    return fh;
+  }
+  // True when the lock is gone or was stale and removed; false when a
+  // live writer still holds it.
+  async reclaimStaleLock(lockPath) {
+    let mtimeMs;
+    try {
+      mtimeMs = (await stat2(lockPath)).mtimeMs;
+    } catch (e) {
+      if (isMissing(e)) return true;
+      throw e;
+    }
+    const age = (Date.now() - mtimeMs) / 1e3;
+    if (age <= LOCK_STALE_SECONDS) return false;
+    console.warn(`mirage: reclaiming stale lock ${lockPath} (age ${age.toFixed(1)}s)`);
+    try {
+      await unlink2(lockPath);
+    } catch (e) {
+      if (!isMissing(e)) throw e;
+    }
+    return true;
+  }
+  async releaseLock(fh, lockPath) {
+    await fh.close();
+    try {
+      await unlink2(lockPath);
+    } catch (e) {
+      if (!isMissing(e)) throw e;
+      console.warn(`mirage: lock ${lockPath} vanished before release (reclaimed?)`);
+    }
+  }
+  async writeRecord(target, fields) {
+    const tmp = `${target}.${String(process.pid)}.${String(tmpCounter++)}.tmp`;
+    await writeFile2(tmp, JSON.stringify(fields));
+    await rename(tmp, target);
+  }
+};
+var DiskSessionStore = class extends SessionStore {
+  records;
+  constructor(root) {
+    super();
+    this.records = new DiskRecordClient(root, "sessions/");
+  }
+  async load() {
+    return await this.records.loadAll();
+  }
+  async set(sessionId, fields) {
+    await this.records.put(sessionId, fields);
+  }
+  async casSet(sessionId, fields, expectedGeneration) {
+    return await this.records.casPut(sessionId, fields, expectedGeneration);
+  }
+  async delete(sessionIds) {
+    await this.records.delete(sessionIds);
+  }
+  async replaceAll(entries) {
+    const stale = (await this.records.listNames()).filter((n) => !entries.has(n));
+    await this.records.delete(stale);
+    await Promise.all([...entries].map(([sid, fields]) => this.records.put(sid, fields)));
+  }
+  async clear() {
+    await this.records.clear();
+  }
+  async close() {
+    await this.records.close();
+  }
+};
+
+// src/workspace/namespace/disk.ts
+var NAMESPACE_RECORD = "namespace";
+var DiskNamespaceStore = class extends NamespaceStore {
+  records;
+  constructor(root) {
+    super();
+    this.records = new DiskRecordClient(root, "");
+  }
+  async state() {
+    const [fields] = await this.records.get(NAMESPACE_RECORD);
+    if (fields === null) return { nodes: {}, user: null };
+    return {
+      nodes: fields.nodes ?? {},
+      user: typeof fields.user === "string" ? fields.user : null
+    };
+  }
+  async write(state) {
+    await this.records.put(NAMESPACE_RECORD, { nodes: state.nodes, user: state.user });
+  }
+  async load() {
+    return new Map(Object.entries((await this.state()).nodes));
+  }
+  async set(path4, fields) {
+    const fh = await this.records.lock(NAMESPACE_RECORD);
+    try {
+      const state = await this.state();
+      state.nodes[path4] = fields;
+      await this.write(state);
+    } finally {
+      await this.records.unlock(NAMESPACE_RECORD, fh);
+    }
+  }
+  async delete(paths) {
+    const fh = await this.records.lock(NAMESPACE_RECORD);
+    try {
+      const state = await this.state();
+      const drop = new Set(paths);
+      state.nodes = Object.fromEntries(
+        Object.entries(state.nodes).filter(([path4]) => !drop.has(path4))
+      );
+      await this.write(state);
+    } finally {
+      await this.records.unlock(NAMESPACE_RECORD, fh);
+    }
+  }
+  async replaceAll(entries) {
+    const fh = await this.records.lock(NAMESPACE_RECORD);
+    try {
+      const state = await this.state();
+      state.nodes = Object.fromEntries(entries);
+      await this.write(state);
+    } finally {
+      await this.records.unlock(NAMESPACE_RECORD, fh);
+    }
+  }
+  async loadUser() {
+    return (await this.state()).user;
+  }
+  async setUser(user) {
+    const fh = await this.records.lock(NAMESPACE_RECORD);
+    try {
+      const state = await this.state();
+      state.user = user;
+      await this.write(state);
+    } finally {
+      await this.records.unlock(NAMESPACE_RECORD, fh);
+    }
+  }
+  async clear() {
+    const fh = await this.records.lock(NAMESPACE_RECORD);
+    try {
+      await this.write({ nodes: {}, user: null });
+    } finally {
+      await this.records.unlock(NAMESPACE_RECORD, fh);
+    }
+  }
+  async close() {
+    await this.records.close();
+  }
+};
+
+// src/workspace/namespace/redis.ts
+import { NamespaceStore as NamespaceStore2 } from "@struktoai/mirage-core";
+var RedisNamespaceStore = class extends NamespaceStore2 {
+  url;
+  key;
+  userKey;
+  clientPromise = null;
+  constructor(options = {}) {
+    super();
+    this.url = options.url ?? "redis://localhost:6379/0";
+    const prefix = options.keyPrefix ?? "mirage:namespace:";
+    this.key = `${prefix}nodes`;
+    this.userKey = `${prefix}user`;
+  }
+  async client() {
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("redis"),
+        { feature: "RedisNamespaceStore", packageName: "redis" }
+      );
+      const c = mod.createClient({
+        url: this.url,
+        socket: { reconnectStrategy: false }
+      });
+      await c.connect();
+      return c;
+    })();
+    return this.clientPromise;
+  }
+  async load() {
+    const c = await this.client();
+    const raw = await c.hGetAll(this.key);
+    const out = /* @__PURE__ */ new Map();
+    for (const [path4, value] of Object.entries(raw)) {
+      out.set(path4, JSON.parse(value));
+    }
+    return out;
+  }
+  async set(path4, fields) {
+    const c = await this.client();
+    await c.hSet(this.key, path4, JSON.stringify(fields));
+  }
+  async delete(paths) {
+    if (paths.length === 0) return;
+    const c = await this.client();
+    await c.hDel(this.key, [...paths]);
+  }
+  async replaceAll(entries) {
+    const c = await this.client();
+    const multi = c.multi().del(this.key);
+    for (const [path4, fields] of entries) {
+      multi.hSet(this.key, path4, JSON.stringify(fields));
+    }
+    await multi.exec();
+  }
+  async loadUser() {
+    const c = await this.client();
+    return c.get(this.userKey);
+  }
+  async setUser(user) {
+    const c = await this.client();
+    await c.set(this.userKey, user);
+  }
+  async clear() {
+    const c = await this.client();
+    await c.del([this.key, this.userKey]);
+  }
+  async close() {
+    if (this.clientPromise === null) return;
+    const pending = this.clientPromise;
+    this.clientPromise = null;
+    const c = await pending;
+    await c.quit();
+  }
+};
+
+// src/workspace/session/redis.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { SessionStore as SessionStore2 } from "@struktoai/mirage-core";
+var CAS_SCRIPT = readFileSync2(new URL("./cas.lua", import.meta.url), "utf8");
+var RedisSessionStore = class extends SessionStore2 {
+  url;
+  key;
+  clientPromise = null;
+  constructor(options = {}) {
+    super();
+    this.url = options.url ?? "redis://localhost:6379/0";
+    const prefix = options.keyPrefix ?? "mirage:session:";
+    this.key = `${prefix}sessions`;
+  }
+  async client() {
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("redis"),
+        { feature: "RedisSessionStore", packageName: "redis" }
+      );
+      const c = mod.createClient({
+        url: this.url,
+        socket: { reconnectStrategy: false }
+      });
+      await c.connect();
+      return c;
+    })();
+    return this.clientPromise;
+  }
+  // One atomic server-side compare-and-set: Lua reads the stored
+  // record's generation and writes only on a match.
+  async casSet(sessionId, fields, expectedGeneration) {
+    const c = await this.client();
+    const result = await c.eval(CAS_SCRIPT, {
+      keys: [this.key],
+      arguments: [sessionId, JSON.stringify(fields), String(expectedGeneration)]
+    });
+    return result === 1;
+  }
+  async load() {
+    const c = await this.client();
+    const raw = await c.hGetAll(this.key);
+    const out = /* @__PURE__ */ new Map();
+    for (const [sid, value] of Object.entries(raw)) {
+      out.set(sid, JSON.parse(value));
+    }
+    return out;
+  }
+  async set(sessionId, fields) {
+    const c = await this.client();
+    await c.hSet(this.key, sessionId, JSON.stringify(fields));
+  }
+  async delete(sessionIds) {
+    if (sessionIds.length === 0) return;
+    const c = await this.client();
+    await c.hDel(this.key, [...sessionIds]);
+  }
+  async replaceAll(entries) {
+    const c = await this.client();
+    const multi = c.multi().del(this.key);
+    for (const [sid, fields] of entries) {
+      multi.hSet(this.key, sid, JSON.stringify(fields));
+    }
+    await multi.exec();
+  }
+  async clear() {
+    const c = await this.client();
+    await c.del(this.key);
+  }
+  async close() {
+    if (this.clientPromise === null) return;
+    const pending = this.clientPromise;
+    this.clientPromise = null;
+    const c = await pending;
+    await c.quit();
+  }
+};
+
+// src/workspace/store/disk.ts
+import { homedir } from "os";
+import path3 from "path";
+import {
+  WorkspaceStateStore
+} from "@struktoai/mirage-core";
+var DEFAULT_STATE_ROOT = "~/.mirage/state";
+function expandHome(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return path3.join(homedir(), p.slice(2));
+  return p;
+}
+function quoteSegment(name) {
+  return encodeURIComponent(name).replace(
+    /[!'()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+var DiskWorkspaceStateStore = class extends WorkspaceStateStore {
+  root;
+  meta = /* @__PURE__ */ new Map();
+  namespaces = /* @__PURE__ */ new Map();
+  observers = /* @__PURE__ */ new Map();
+  sessionTables = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const { root, ...overrides } = options;
+    super(overrides);
+    this.root = expandHome(root ?? DEFAULT_STATE_ROOT);
+  }
+  wsRoot(workspaceId) {
+    return path3.join(this.root, "workspaces", quoteSegment(workspaceId));
+  }
+  metaClient(workspaceId) {
+    let client = this.meta.get(workspaceId);
+    if (client === void 0) {
+      client = new DiskRecordClient(this.wsRoot(workspaceId), "");
+      this.meta.set(workspaceId, client);
+    }
+    return client;
+  }
+  makeNamespace(workspaceId) {
+    let ns = this.namespaces.get(workspaceId);
+    if (ns === void 0) {
+      ns = new DiskNamespaceStore(this.wsRoot(workspaceId));
+      this.namespaces.set(workspaceId, ns);
+    }
+    return ns;
+  }
+  makeObserver(workspaceId) {
+    let ob = this.observers.get(workspaceId);
+    if (ob === void 0) {
+      ob = new DiskObserverStore(path3.join(this.wsRoot(workspaceId), "history"));
+      this.observers.set(workspaceId, ob);
+    }
+    return ob;
+  }
+  makeSessions(workspaceId) {
+    let table = this.sessionTables.get(workspaceId);
+    if (table === void 0) {
+      table = new DiskSessionStore(this.wsRoot(workspaceId));
+      this.sessionTables.set(workspaceId, table);
+    }
+    return table;
+  }
+  async readMeta(workspaceId) {
+    const [fields] = await this.metaClient(workspaceId).get("workspace");
+    return fields;
+  }
+  async writeMeta(workspaceId, fields) {
+    await this.metaClient(workspaceId).put("workspace", fields);
+  }
+  async casWriteMeta(workspaceId, fields, expectedGeneration) {
+    return await this.metaClient(workspaceId).casPut("workspace", fields, expectedGeneration);
+  }
+  async closeSelf() {
+    for (const ns of this.namespaces.values()) await ns.close();
+    for (const ob of this.observers.values()) await ob.close();
+    for (const table of this.sessionTables.values()) await table.close();
+    for (const client of this.meta.values()) await client.close();
+  }
+};
+
+// src/workspace/store/redis.ts
+import {
+  WorkspaceStateStore as WorkspaceStateStore2
+} from "@struktoai/mirage-core";
+var RedisWorkspaceStateStore = class extends WorkspaceStateStore2 {
+  url;
+  prefix;
+  metaKey;
+  clientPromise = null;
+  namespaces = /* @__PURE__ */ new Map();
+  observers = /* @__PURE__ */ new Map();
+  sessionTables = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const { url, keyPrefix, ...overrides } = options;
+    super(overrides);
+    this.url = url ?? "redis://localhost:6379/0";
+    this.prefix = keyPrefix ?? "mirage:";
+    this.metaKey = `${this.prefix}workspaces`;
+  }
+  async client() {
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("redis"),
+        { feature: "RedisWorkspaceStateStore", packageName: "redis" }
+      );
+      const c = mod.createClient({
+        url: this.url,
+        socket: { reconnectStrategy: false }
+      });
+      await c.connect();
+      return c;
+    })();
+    return this.clientPromise;
+  }
+  makeNamespace(workspaceId) {
+    let ns = this.namespaces.get(workspaceId);
+    if (ns === void 0) {
+      ns = new RedisNamespaceStore({
+        url: this.url,
+        keyPrefix: `${this.prefix}${workspaceId}:namespace:`
+      });
+      this.namespaces.set(workspaceId, ns);
+    }
+    return ns;
+  }
+  makeObserver(workspaceId) {
+    let ob = this.observers.get(workspaceId);
+    if (ob === void 0) {
+      ob = new RedisObserverStore({
+        url: this.url,
+        keyPrefix: `${this.prefix}${workspaceId}:observer:`
+      });
+      this.observers.set(workspaceId, ob);
+    }
+    return ob;
+  }
+  makeSessions(workspaceId) {
+    let table = this.sessionTables.get(workspaceId);
+    if (table === void 0) {
+      table = new RedisSessionStore({
+        url: this.url,
+        keyPrefix: `${this.prefix}${workspaceId}:`
+      });
+      this.sessionTables.set(workspaceId, table);
+    }
+    return table;
+  }
+  async readMeta(workspaceId) {
+    const c = await this.client();
+    const raw = await c.hGet(this.metaKey, workspaceId);
+    return raw != null ? JSON.parse(raw) : null;
+  }
+  async writeMeta(workspaceId, fields) {
+    const c = await this.client();
+    await c.hSet(this.metaKey, workspaceId, JSON.stringify(fields));
+  }
+  // Same generic hash-field CAS the session store uses: the meta hash
+  // is keyed by workspace id instead of session id.
+  async casWriteMeta(workspaceId, fields, expectedGeneration) {
+    const c = await this.client();
+    const result = await c.eval(CAS_SCRIPT, {
+      keys: [this.metaKey],
+      arguments: [workspaceId, JSON.stringify(fields), String(expectedGeneration)]
+    });
+    return result === 1;
+  }
+  async closeSelf() {
+    for (const ns of this.namespaces.values()) await ns.close();
+    for (const ob of this.observers.values()) await ob.close();
+    for (const table of this.sessionTables.values()) await table.close();
+    if (this.clientPromise !== null) {
+      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 {
-    return ws.registry.mountFor(p) !== null;
+    const m = ws.registry.mountFor(p);
+    if (m === null) return false;
+    if (ws.syntheticRoot && m === ws.registry.rootMount) return false;
+    return true;
   } catch {
     return false;
   }
@@ -1224,7 +2269,7 @@ async function resolveSizes(accessor, paths, index) {
   const resolved = [];
   let missing = 0;
   for (const p of paths) {
-    const pathStr = p.original;
+    const pathStr = p.virtual;
     let size = null;
     if (index !== void 0) {
       const lookup = await index.get(pathStr);
@@ -1292,13 +2337,19 @@ function metadataProvision(_accessor, paths, _texts, _opts) {
 // src/cache/redis/file.ts
 import {
   defaultFingerprint,
-  parseLimit
+  parseLimit,
+  validateMaxDrainBytes
 } from "@struktoai/mirage-core";
 var RedisFileCacheStore = class extends RedisResource {
+  // Advisory only: unlike the RAM store there is no client-side LRU, so
+  // nothing evicts on overflow. Cap memory on the Redis server instead
+  // (maxmemory + maxmemory-policy allkeys-lru) to approximate the RAM
+  // store's eviction behavior.
   limit;
   dataPrefix;
   metaPrefix;
-  maxDrainBytes;
+  maxDrainBytesValue = null;
+  drainTasks = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     super({
       url: options.url ?? "redis://localhost:6379/0",
@@ -1309,7 +2360,16 @@ var RedisFileCacheStore = class extends RedisResource {
     this.metaPrefix = `${this.keyPrefix}meta:`;
     this.maxDrainBytes = options.maxDrainBytes ?? null;
   }
-  cacheSize = 0;
+  get maxDrainBytes() {
+    return this.maxDrainBytesValue;
+  }
+  set maxDrainBytes(value) {
+    validateMaxDrainBytes(this.limit, value);
+    this.maxDrainBytesValue = value;
+  }
+  // Size lives in the redis server and is not tracked client-side.
+  cacheSize = null;
+  cacheEntries = null;
   get cacheLimit() {
     return this.limit;
   }
@@ -1348,6 +2408,7 @@ var RedisFileCacheStore = class extends RedisResource {
     return true;
   }
   async remove(key) {
+    this.drainTasks.delete(key);
     const c = await this.cacheClient();
     const pipe = c.multi();
     pipe.del(`${this.dataPrefix}${key}`);
@@ -1355,7 +2416,7 @@ var RedisFileCacheStore = class extends RedisResource {
     await pipe.exec();
   }
   async exists(key) {
-    const k = typeof key === "string" ? key : key.stripPrefix;
+    const k = typeof key === "string" ? key : key.mountPath;
     const c = await this.cacheClient();
     return await c.exists(`${this.dataPrefix}${k}`) > 0;
   }
@@ -1366,6 +2427,7 @@ var RedisFileCacheStore = class extends RedisResource {
     return fp === remoteFingerprint;
   }
   async clear() {
+    this.drainTasks.clear();
     const c = await this.cacheClient();
     for (const pattern of [`${this.dataPrefix}*`, `${this.metaPrefix}*`]) {
       const batch = [];
@@ -1501,7 +2563,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 +2573,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,208 +2608,218 @@ var REGISTRY = {
     return new RAMResource();
   },
   disk: async (config) => {
-    const { DiskResource: DiskResource2 } = await import("./disk-POACMF4G.js");
+    const { DiskResource: DiskResource2 } = await import("./disk-24NWTN2I.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-6D55Q2WB.js");
     const norm = normalizeFields(config);
     return new RedisResource2(norm);
   },
   s3: async (config) => {
-    const { S3Resource: S3Resource2 } = await import("./s3-GMPUJ65D.js");
-    const { normalizeS3Config } = await import("./config-QWCY3LBQ.js");
+    const { S3Resource: S3Resource2 } = await import("./s3-XQBI2CXN.js");
+    const { normalizeS3Config } = await import("./config-BBOLI7VE.js");
     return new S3Resource2(normalizeS3Config(config));
   },
+  gridfs: async (config) => {
+    const { GridFSResource: GridFSResource2 } = await import("./gridfs-KZRZ6SIB.js");
+    const { normalizeGridFSConfig: normalizeGridFSConfig2 } = await import("./config-J2C53GOT.js");
+    return new GridFSResource2(normalizeGridFSConfig2(config));
+  },
   gcs: async (config) => {
-    const { GCSResource: GCSResource2 } = await import("./gcs-SMIE4VMT.js");
-    const { normalizeGcsConfig } = await import("./config-VM526IKB.js");
+    const { GCSResource: GCSResource2 } = await import("./gcs-PFWR6MIW.js");
+    const { normalizeGcsConfig } = await import("./config-BIBFLUIR.js");
     return new GCSResource2(normalizeGcsConfig(config));
   },
   oci: async (config) => {
-    const { OCIResource: OCIResource2 } = await import("./oci-NURLWPL2.js");
-    const { normalizeOciConfig } = await import("./config-KYTRXAB2.js");
+    const { OCIResource: OCIResource2 } = await import("./oci-CKYBSFZJ.js");
+    const { normalizeOciConfig } = await import("./config-W7EVPJNK.js");
     return new OCIResource2(normalizeOciConfig(config));
   },
   r2: async (config) => {
-    const { R2Resource: R2Resource2 } = await import("./r2-FSZK7IFI.js");
-    const { normalizeR2Config } = await import("./config-KMVCVBYN.js");
+    const { R2Resource: R2Resource2 } = await import("./r2-C4XGEWQY.js");
+    const { normalizeR2Config } = await import("./config-WVILHDFV.js");
     return new R2Resource2(normalizeR2Config(config));
   },
   hf_buckets: async (config) => {
-    const { HfBucketsResource: HfBucketsResource2 } = await import("./hf_buckets-RIOMV7WG.js");
-    const { normalizeHfBucketsConfig: normalizeHfBucketsConfig2 } = await import("./config-CVZ2AGCO.js");
+    const { HfBucketsResource: HfBucketsResource2 } = await import("./hf_buckets-BK7NGJWS.js");
+    const { normalizeHfBucketsConfig: normalizeHfBucketsConfig2 } = await import("./config-SPW6NESU.js");
     return new HfBucketsResource2(normalizeHfBucketsConfig2(config));
   },
   hf_datasets: async (config) => {
-    const { HfDatasetsResource: HfDatasetsResource2 } = await import("./hf_datasets-QF4BQ3OK.js");
-    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-CVZ2AGCO.js");
+    const { HfDatasetsResource: HfDatasetsResource2 } = await import("./hf_datasets-UQ5QGM4L.js");
+    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-SPW6NESU.js");
     return new HfDatasetsResource2(normalizeHfRepoConfig2(config));
   },
   hf_models: async (config) => {
-    const { HfModelsResource: HfModelsResource2 } = await import("./hf_models-62GC2HPZ.js");
-    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-CVZ2AGCO.js");
+    const { HfModelsResource: HfModelsResource2 } = await import("./hf_models-75LFCQCS.js");
+    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-SPW6NESU.js");
     return new HfModelsResource2(normalizeHfRepoConfig2(config));
   },
   hf_spaces: async (config) => {
-    const { HfSpacesResource: HfSpacesResource2 } = await import("./hf_spaces-NVSMUNRM.js");
-    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-CVZ2AGCO.js");
+    const { HfSpacesResource: HfSpacesResource2 } = await import("./hf_spaces-6T2KB3UC.js");
+    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-SPW6NESU.js");
     return new HfSpacesResource2(normalizeHfRepoConfig2(config));
   },
   supabase: async (config) => {
-    const { SupabaseResource: SupabaseResource2 } = await import("./supabase-HLWNHBBE.js");
-    const { normalizeSupabaseConfig } = await import("./config-GE4W4ZJC.js");
+    const { SupabaseResource: SupabaseResource2 } = await import("./supabase-BBM44UTM.js");
+    const { normalizeSupabaseConfig } = await import("./config-EX3ZJTZI.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-ETRDJVVQ.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 { normalizeMinIOConfig } = await import("./config-34LHOGLM.js");
+    const { MinIOResource: MinIOResource2 } = await import("./minio-IZRZY4C5.js");
+    const { normalizeMinIOConfig } = await import("./config-2LASFFRD.js");
     return new MinIOResource2(normalizeMinIOConfig(config));
   },
   ceph: async (config) => {
-    const { CephResource: CephResource2 } = await import("./ceph-TNN4I2FT.js");
-    const { normalizeCephConfig } = await import("./config-ZFJYQZCH.js");
+    const { CephResource: CephResource2 } = await import("./ceph-C265UI5T.js");
+    const { normalizeCephConfig } = await import("./config-54USUVSE.js");
     return new CephResource2(normalizeCephConfig(config));
   },
   seaweedfs: async (config) => {
-    const { SeaweedFSResource: SeaweedFSResource2 } = await import("./seaweedfs-J3EPUEPE.js");
-    const { normalizeSeaweedFSConfig } = await import("./config-GHRUKEQ6.js");
+    const { SeaweedFSResource: SeaweedFSResource2 } = await import("./seaweedfs-3XYIAFU2.js");
+    const { normalizeSeaweedFSConfig } = await import("./config-OJ2BPESH.js");
     return new SeaweedFSResource2(normalizeSeaweedFSConfig(config));
   },
   wasabi: async (config) => {
-    const { WasabiResource: WasabiResource2 } = await import("./wasabi-SOZKPMRQ.js");
-    const { normalizeWasabiConfig } = await import("./config-QAA646XB.js");
+    const { WasabiResource: WasabiResource2 } = await import("./wasabi-O4MVIUFG.js");
+    const { normalizeWasabiConfig } = await import("./config-T2IUIU5C.js");
     return new WasabiResource2(normalizeWasabiConfig(config));
   },
   backblaze: async (config) => {
-    const { BackblazeResource: BackblazeResource2 } = await import("./backblaze-OHW57DLK.js");
-    const { normalizeBackblazeConfig } = await import("./config-WDAZFXYD.js");
+    const { BackblazeResource: BackblazeResource2 } = await import("./backblaze-TSPL6Y56.js");
+    const { normalizeBackblazeConfig } = await import("./config-QO2XUME4.js");
     return new BackblazeResource2(normalizeBackblazeConfig(config));
   },
   digitalocean: async (config) => {
-    const { DigitalOceanResource: DigitalOceanResource2 } = await import("./digitalocean-6SPR4S7V.js");
-    const { normalizeDigitalOceanConfig } = await import("./config-Q45Y46YT.js");
+    const { DigitalOceanResource: DigitalOceanResource2 } = await import("./digitalocean-QP72DR4J.js");
+    const { normalizeDigitalOceanConfig } = await import("./config-XU6D5C7E.js");
     return new DigitalOceanResource2(normalizeDigitalOceanConfig(config));
   },
   tencent: async (config) => {
-    const { TencentResource: TencentResource2 } = await import("./tencent-YDO73XBD.js");
-    const { normalizeTencentConfig } = await import("./config-QNMKWJ4M.js");
+    const { TencentResource: TencentResource2 } = await import("./tencent-X72USLJ7.js");
+    const { normalizeTencentConfig } = await import("./config-FRK7ZL37.js");
     return new TencentResource2(normalizeTencentConfig(config));
   },
   aliyun: async (config) => {
-    const { AliyunResource: AliyunResource2 } = await import("./aliyun-TMZRUYCG.js");
-    const { normalizeAliyunConfig } = await import("./config-HKRMKD76.js");
+    const { AliyunResource: AliyunResource2 } = await import("./aliyun-PGI57A43.js");
+    const { normalizeAliyunConfig } = await import("./config-IPNWAJHH.js");
     return new AliyunResource2(normalizeAliyunConfig(config));
   },
   scaleway: async (config) => {
-    const { ScalewayResource: ScalewayResource2 } = await import("./scaleway-5VM55Y6D.js");
-    const { normalizeScalewayConfig } = await import("./config-EO23EY62.js");
+    const { ScalewayResource: ScalewayResource2 } = await import("./scaleway-SEZJVURB.js");
+    const { normalizeScalewayConfig } = await import("./config-CPYFOUQO.js");
     return new ScalewayResource2(normalizeScalewayConfig(config));
   },
   qingstor: async (config) => {
-    const { QingStorResource: QingStorResource2 } = await import("./qingstor-W55D5YFO.js");
-    const { normalizeQingStorConfig } = await import("./config-IVY5EQQ2.js");
+    const { QingStorResource: QingStorResource2 } = await import("./qingstor-AP4IIPLY.js");
+    const { normalizeQingStorConfig } = await import("./config-M3Z47VYU.js");
     return new QingStorResource2(normalizeQingStorConfig(config));
   },
   postgres: async (config) => {
-    const { PostgresResource: PostgresResource2 } = await import("./postgres-JNFMPAO2.js");
+    const { PostgresResource: PostgresResource2 } = await import("./postgres-WIQBVL5M.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-VMKPQCPX.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 { normalizeSlackConfig: normalizeSlackConfig2 } = await import("./config-ZV6G2ZEC.js");
+    const { SlackResource: SlackResource2 } = await import("./slack-ZHXDJQY4.js");
+    const { normalizeSlackConfig: normalizeSlackConfig2 } = await import("./config-4QV4QYI5.js");
     return new SlackResource2(normalizeSlackConfig2(config));
   },
   ssh: async (config) => {
-    const { SSHResource: SSHResource2 } = await import("./ssh-GCXETJ3Z.js");
-    const { normalizeSshConfig: normalizeSshConfig2 } = await import("./config-KJOLGVB2.js");
+    const { SSHResource: SSHResource2 } = await import("./ssh-X2MO7JOV.js");
+    const { normalizeSshConfig: normalizeSshConfig2 } = await import("./config-VKKZGC7V.js");
     return new SSHResource2(normalizeSshConfig2(config));
   },
+  nextcloud: async (config) => {
+    const { NextcloudResource: NextcloudResource2 } = await import("./nextcloud-5RHQCGDO.js");
+    const { normalizeNextcloudConfig: normalizeNextcloudConfig2 } = await import("./config-E22XAGYN.js");
+    return new NextcloudResource2(normalizeNextcloudConfig2(config));
+  },
   discord: async (config) => {
-    const { DiscordResource: DiscordResource2 } = await import("./discord-SAV2RBJV.js");
-    const { normalizeDiscordConfig: normalizeDiscordConfig2 } = await import("./config-DG65OEG3.js");
+    const { DiscordResource: DiscordResource2 } = await import("./discord-BSN5RB3E.js");
+    const { normalizeDiscordConfig: normalizeDiscordConfig2 } = await import("./config-EHE52ZTK.js");
     return new DiscordResource2(normalizeDiscordConfig2(config));
   },
   trello: async (config) => {
-    const { TrelloResource: TrelloResource2 } = await import("./trello-CQ53BQUL.js");
-    const { normalizeTrelloConfig: normalizeTrelloConfig2 } = await import("./config-GVH27UPE.js");
+    const { TrelloResource: TrelloResource2 } = await import("./trello-EER5NG7L.js");
+    const { normalizeTrelloConfig: normalizeTrelloConfig2 } = await import("./config-QWQGOXQ5.js");
     return new TrelloResource2(normalizeTrelloConfig2(config));
   },
   linear: async (config) => {
-    const { LinearResource: LinearResource2 } = await import("./linear-2MM55KBC.js");
-    const { normalizeLinearConfig: normalizeLinearConfig2 } = await import("./config-GCQK6NJY.js");
+    const { LinearResource: LinearResource2 } = await import("./linear-V3TXO6CV.js");
+    const { normalizeLinearConfig: normalizeLinearConfig2 } = await import("./config-LEALEMKA.js");
     return new LinearResource2(normalizeLinearConfig2(config));
   },
   notion: async (config) => {
-    const { NotionResource: NotionResource2 } = await import("./notion-UK4GTMT4.js");
-    const { normalizeNotionConfig: normalizeNotionConfig2 } = await import("./config-IJJXGLBQ.js");
+    const { NotionResource: NotionResource2 } = await import("./notion-6PPNTQFM.js");
+    const { normalizeNotionConfig: normalizeNotionConfig2 } = await import("./config-HTXOOAOD.js");
     return new NotionResource2(normalizeNotionConfig2(config));
   },
   langfuse: async (config) => {
-    const { LangfuseResource: LangfuseResource2 } = await import("./langfuse-HUAYVPHF.js");
-    const { normalizeLangfuseConfig: normalizeLangfuseConfig2 } = await import("./config-LHFFXVYI.js");
+    const { LangfuseResource: LangfuseResource2 } = await import("./langfuse-AMQCQWNE.js");
+    const { normalizeLangfuseConfig: normalizeLangfuseConfig2 } = await import("./config-HQXNFQZS.js");
     return new LangfuseResource2(normalizeLangfuseConfig2(config));
   },
   github: async (config) => {
-    const { GitHubResource: GitHubResource2 } = await import("./github-KBHWANKQ.js");
-    const { normalizeGitHubConfig: normalizeGitHubConfig2 } = await import("./config-3BBWD5AB.js");
+    const { GitHubResource: GitHubResource2 } = await import("./github-EQ4NXUTA.js");
+    const { normalizeGitHubConfig: normalizeGitHubConfig2 } = await import("./config-WKQ3FGTZ.js");
     return GitHubResource2.create(normalizeGitHubConfig2(config));
   },
   github_ci: async (config) => {
-    const { GitHubCIResource: GitHubCIResource2 } = await import("./github_ci-HPITNK37.js");
-    const { normalizeGitHubCIConfig: normalizeGitHubCIConfig2 } = await import("./config-EIHSP5DZ.js");
+    const { GitHubCIResource: GitHubCIResource2 } = await import("./github_ci-QL5B2Q2N.js");
+    const { normalizeGitHubCIConfig: normalizeGitHubCIConfig2 } = await import("./config-MZM3IPFM.js");
     return new GitHubCIResource2(normalizeGitHubCIConfig2(config));
   },
   gdocs: async (config) => {
-    const { GDocsResource: GDocsResource2 } = await import("./gdocs-X5Y2SIQX.js");
-    const { normalizeGDocsConfig: normalizeGDocsConfig2 } = await import("./config-D3RLSPNF.js");
+    const { GDocsResource: GDocsResource2 } = await import("./gdocs-GPAZRQG5.js");
+    const { normalizeGDocsConfig: normalizeGDocsConfig2 } = await import("./config-3WDIJPTG.js");
     return new GDocsResource2(normalizeGDocsConfig2(config));
   },
   gsheets: async (config) => {
-    const { GSheetsResource: GSheetsResource2 } = await import("./gsheets-ZSUDIWGK.js");
-    const { normalizeGSheetsConfig: normalizeGSheetsConfig2 } = await import("./config-OT2TQQCN.js");
+    const { GSheetsResource: GSheetsResource2 } = await import("./gsheets-N53WEXN2.js");
+    const { normalizeGSheetsConfig: normalizeGSheetsConfig2 } = await import("./config-5ZXN2T2H.js");
     return new GSheetsResource2(normalizeGSheetsConfig2(config));
   },
   gslides: async (config) => {
-    const { GSlidesResource: GSlidesResource2 } = await import("./gslides-GYXM7IMJ.js");
-    const { normalizeGSlidesConfig: normalizeGSlidesConfig2 } = await import("./config-IDZMEW73.js");
+    const { GSlidesResource: GSlidesResource2 } = await import("./gslides-TATSARTH.js");
+    const { normalizeGSlidesConfig: normalizeGSlidesConfig2 } = await import("./config-RI7IEZUF.js");
     return new GSlidesResource2(normalizeGSlidesConfig2(config));
   },
   gdrive: async (config) => {
-    const { GDriveResource: GDriveResource2 } = await import("./gdrive-SIQPRIGI.js");
-    const { normalizeGDriveConfig: normalizeGDriveConfig2 } = await import("./config-HXVYIXP5.js");
+    const { GDriveResource: GDriveResource2 } = await import("./gdrive-XSX6A7B3.js");
+    const { normalizeGDriveConfig: normalizeGDriveConfig2 } = await import("./config-K63RX6EU.js");
     return new GDriveResource2(normalizeGDriveConfig2(config));
   },
   dropbox: async (config) => {
-    const { DropboxResource: DropboxResource2 } = await import("./dropbox-CQ7MTYX2.js");
-    const { normalizeDropboxConfig: normalizeDropboxConfig2 } = await import("./config-4UDVSUQJ.js");
+    const { DropboxResource: DropboxResource2 } = await import("./dropbox-OSTZXSIE.js");
+    const { normalizeDropboxConfig: normalizeDropboxConfig2 } = await import("./config-L7SBSH5L.js");
     return new DropboxResource2(normalizeDropboxConfig2(config));
   },
   box: async (config) => {
-    const { BoxResource: BoxResource2 } = await import("./box-UXTCAFOZ.js");
-    const { normalizeBoxConfig: normalizeBoxConfig2 } = await import("./config-CMDBAPDH.js");
+    const { BoxResource: BoxResource2 } = await import("./box-7XTZYDSO.js");
+    const { normalizeBoxConfig: normalizeBoxConfig2 } = await import("./config-A2GQYJDB.js");
     return new BoxResource2(normalizeBoxConfig2(config));
   },
   gmail: async (config) => {
-    const { GmailResource: GmailResource2 } = await import("./gmail-DKHAGJNX.js");
-    const { normalizeGmailConfig } = await import("./config-NV5WXP64.js");
+    const { GmailResource: GmailResource2 } = await import("./gmail-2TBT4CVH.js");
+    const { normalizeGmailConfig } = await import("./config-UU27ALAA.js");
     return new GmailResource2(normalizeGmailConfig(config));
   },
   email: async (config) => {
-    const { EmailResource: EmailResource2 } = await import("./email-KBQ7CXS7.js");
-    const { normalizeEmailConfig: normalizeEmailConfig2 } = await import("./config-3IVQJBNW.js");
+    const { EmailResource: EmailResource2 } = await import("./email-4ZFPSWIN.js");
+    const { normalizeEmailConfig: normalizeEmailConfig2 } = await import("./config-DWSJL3NH.js");
     return new EmailResource2(normalizeEmailConfig2(config));
   }
 };
@@ -1774,6 +2846,7 @@ export {
   BoxResource,
   CEPH_PROMPT,
   CephResource,
+  DEFAULT_STATE_ROOT,
   DIGITALOCEAN_PROMPT,
   DISK_COMMANDS,
   DISK_OPS,
@@ -1781,7 +2854,12 @@ export {
   DatabricksVolumeResource,
   DigitalOceanResource,
   DiscordResource,
+  DiskNamespaceStore,
+  DiskObserverStore,
+  DiskRecordClient,
   DiskResource,
+  DiskSessionStore,
+  DiskWorkspaceStateStore,
   DropboxResource,
   EMAIL_COMMANDS,
   EMAIL_OPS,
@@ -1800,6 +2878,8 @@ export {
   GitHubCIResource,
   GitHubResource,
   GmailResource,
+  GridFSAccessor,
+  GridFSResource,
   HF_BUCKETS_PROMPT,
   HF_COMMANDS,
   HF_DATASETS_PROMPT,
@@ -1826,6 +2906,12 @@ export {
   MirageFS,
   MongoDBResource,
   MongoDBStore,
+  Mount,
+  NEXTCLOUD_COMMANDS,
+  NEXTCLOUD_OPS,
+  NEXTCLOUD_PROMPT,
+  NextcloudAccessor,
+  NextcloudResource,
   NotionResource,
   OCIResource,
   OCI_PROMPT,
@@ -1840,8 +2926,12 @@ export {
   REDIS_PROMPT,
   RedisAccessor,
   RedisFileCacheStore,
+  RedisNamespaceStore,
+  RedisObserverStore,
   RedisResource,
+  RedisSessionStore,
   RedisStore,
+  RedisWorkspaceStateStore,
   S3Resource,
   SCALEWAY_PROMPT,
   SEAWEEDFS_PROMPT,
@@ -1883,11 +2973,13 @@ export {
   normalizeGitHubCIConfig,
   normalizeGitHubConfig,
   normalizeGoogleConfig as normalizeGmailConfig,
+  normalizeGridFSConfig,
   normalizeHfBucketsConfig,
   normalizeHfModelsConfig,
   normalizeHfRepoConfig,
   normalizeLangfuseConfig,
   normalizeLinearConfig,
+  normalizeNextcloudConfig,
   normalizeNotionConfig,
   normalizeSlackConfig,
   normalizeSshConfig,
@@ -1916,6 +3008,7 @@ export {
   redactLangfuseConfig,
   redactLinearConfig,
   redactMinIOConfig,
+  redactNextcloudConfig,
   redactNotionConfig,
   redactOciConfig,
   redactQingStorConfig,