@struktoai/mirage-node 0.0.3 → 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-MPCCRRE6.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-S5OVP467.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-A7IVFIOP.js";
+} from "./chunk-YRJICL2Q.js";
+import {
+  normalizeGSlidesConfig,
+  redactGSlidesConfig
+} from "./chunk-GTAS3QVC.js";
 import {
   GDriveResource
-} from "./chunk-QCZ2XUKH.js";
+} from "./chunk-VLRSOWHP.js";
 import {
   normalizeGDriveConfig,
   redactGDriveConfig
-} from "./chunk-DP2PP5V2.js";
-import {
-  DropboxResource
-} from "./chunk-SWCDFEUK.js";
+} from "./chunk-KGC2OGXI.js";
 import {
   normalizeDropboxConfig,
   redactDropboxConfig
-} from "./chunk-Q2IAILVC.js";
+} from "./chunk-HSD24IP2.js";
 import {
-  BoxResource
-} from "./chunk-VWKUT4CW.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-LV2G7VHL.js";
+} from "./chunk-5YRWF5RP.js";
+import {
+  normalizeGitHubConfig,
+  redactGitHubConfig
+} from "./chunk-XUUSWR4U.js";
 import {
   GitHubCIResource
-} from "./chunk-EZQ5HBAC.js";
+} from "./chunk-JBDFYIN2.js";
 import {
   normalizeGitHubCIConfig,
   redactGitHubCIConfig
-} from "./chunk-H3I2KZIY.js";
-import {
-  GDocsResource
-} from "./chunk-JCC4CU2I.js";
+} from "./chunk-ZPB3SLPK.js";
 import {
   normalizeGDocsConfig,
   redactGDocsConfig
-} from "./chunk-H3BST2LI.js";
+} from "./chunk-JHI2PHHD.js";
 import {
-  GSheetsResource
-} from "./chunk-ZEGAMJO2.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-WAR4Q2NM.js";
+} from "./chunk-3JZN3GYO.js";
+import {
+  normalizeTrelloConfig,
+  redactTrelloConfig
+} from "./chunk-NJ42VNXG.js";
 import {
   LinearResource
-} from "./chunk-G2WCEUQL.js";
+} from "./chunk-ZMREYTHA.js";
 import {
   normalizeLinearConfig,
   redactLinearConfig
-} from "./chunk-YUK3X3B4.js";
-import {
-  NotionResource
-} from "./chunk-NOHWIBRX.js";
+} from "./chunk-IKJQOYI4.js";
 import {
   normalizeNotionConfig,
   redactNotionConfig
-} from "./chunk-JZT4QGIP.js";
-import {
-  LangfuseResource
-} from "./chunk-EM4J5EQS.js";
+} from "./chunk-VIICUPWQ.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-GCFYZSVR.js";
+} from "./chunk-FRGTDZQT.js";
 import {
   SlackResource
-} from "./chunk-M5FVUIYP.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-WHFUWWI6.js";
+} from "./chunk-5ZHNPNDD.js";
 import {
   normalizeSshConfig,
   redactSshConfig
-} from "./chunk-UGK4TAVK.js";
-import {
-  DiscordResource
-} from "./chunk-JAGJTM3Q.js";
+} from "./chunk-LPLZLSMK.js";
 import {
-  normalizeDiscordConfig,
-  redactDiscordConfig
-} from "./chunk-DNBAMB5J.js";
+  normalizeNextcloudConfig,
+  redactNextcloudConfig
+} from "./chunk-MRXTUFBZ.js";
 import {
-  normalizeTrelloConfig,
-  redactTrelloConfig
-} from "./chunk-RO5IQEDQ.js";
+  DIGITALOCEAN_PROMPT,
+  DigitalOceanResource
+} from "./chunk-CXQGMFI7.js";
 import {
   TENCENT_PROMPT,
   TencentResource
-} from "./chunk-YAHRT6MB.js";
+} from "./chunk-EGZNOUMH.js";
+import {
+  redactTencentConfig,
+  resolvedTencentEndpoint
+} from "./chunk-WTSSEUOZ.js";
 import {
   ALIYUN_PROMPT,
   AliyunResource
-} from "./chunk-FQ33BYFR.js";
+} from "./chunk-XEMLYWHK.js";
 import {
   redactAliyunConfig,
   resolvedAliyunEndpoint
-} from "./chunk-NJMGCT63.js";
+} from "./chunk-2QNPKPZZ.js";
 import {
   SCALEWAY_PROMPT,
   ScalewayResource
-} from "./chunk-3WIO7NBR.js";
+} from "./chunk-L4GMDSMB.js";
 import {
   redactScalewayConfig,
   resolvedScalewayEndpoint
-} from "./chunk-XLQI4IT2.js";
-import {
-  QINGSTOR_PROMPT,
-  QingStorResource
-} from "./chunk-QQBJC2FQ.js";
+} from "./chunk-YBVMZ7SR.js";
 import {
   redactQingStorConfig,
   resolvedQingStorEndpoint
-} from "./chunk-OHROA3FQ.js";
+} from "./chunk-WWP2STF5.js";
 import {
-  PostgresResource,
-  PostgresStore
-} from "./chunk-GS5AUKUO.js";
+  SEAWEEDFS_PROMPT,
+  SeaweedFSResource
+} from "./chunk-NLXJMXVE.js";
 import {
   CEPH_PROMPT,
   CephResource
-} from "./chunk-IK2L4EN3.js";
+} from "./chunk-XADEMW6B.js";
+import {
+  redactCephConfig
+} from "./chunk-UYA3XL3J.js";
 import {
   WASABI_PROMPT,
   WasabiResource
-} from "./chunk-47AVIIOT.js";
+} from "./chunk-L7FEZ7LU.js";
 import {
   redactWasabiConfig,
   resolvedWasabiEndpoint
-} from "./chunk-JALIYI6M.js";
+} from "./chunk-S4KVLPBR.js";
 import {
   BACKBLAZE_PROMPT,
   BackblazeResource
-} from "./chunk-X3G37FXT.js";
+} from "./chunk-SYMNWNC3.js";
 import {
   redactBackblazeConfig,
   resolvedBackblazeEndpoint
-} from "./chunk-XHCBHYN4.js";
-import {
-  DIGITALOCEAN_PROMPT,
-  DigitalOceanResource
-} from "./chunk-KPULTUOK.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-N5FSLVKO.js";
+} from "./chunk-DXU7NZPH.js";
 import {
   HF_MODELS_PROMPT,
   HfModelsResource
-} from "./chunk-UINQOUZR.js";
+} from "./chunk-V7JVMG63.js";
 import {
   HF_SPACES_PROMPT,
   HfSpacesResource
-} from "./chunk-X5HF2OFP.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-7CW3BMPH.js";
+} from "./chunk-4X6CLF4F.js";
 import {
   redactMinIOConfig
-} from "./chunk-DYXEITK3.js";
-import {
-  SEAWEEDFS_PROMPT,
-  SeaweedFSResource
-} from "./chunk-AUHSTJJ3.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-DM4GSE26.js";
+} from "./chunk-TUNR4VUM.js";
 import {
   redactOciConfig
-} from "./chunk-RQK5UPMP.js";
+} from "./chunk-H62XQZUM.js";
 import {
   R2Resource,
   R2_PROMPT
-} from "./chunk-ZGSER5TG.js";
+} from "./chunk-ZM44MGC5.js";
 import {
   redactR2Config
-} from "./chunk-LAJJPLEV.js";
+} from "./chunk-VBYIDRNU.js";
 import {
   SUPABASE_PROMPT,
   SupabaseResource
-} from "./chunk-HGCRXJGP.js";
+} from "./chunk-F5NWRF32.js";
 import {
   redactSupabaseConfig,
   resolvedSupabaseEndpoint
-} from "./chunk-QGRDPSAH.js";
-import {
-  HF_BUCKETS_PROMPT,
-  HfBucketsResource
-} from "./chunk-HJJMP6IX.js";
-import {
-  HF_COMMANDS,
-  HF_OPS,
-  HF_RESOURCES,
-  HfAccessor,
-  HfBucketsAccessor,
-  HfDatasetsAccessor,
-  HfModelsAccessor,
-  HfSpacesAccessor
-} from "./chunk-TURD42QO.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-XWVDS66D.js";
-import "./chunk-U6QSXTUS.js";
+} from "./chunk-W5ZLIQFR.js";
 import {
   REDIS_COMMANDS,
   REDIS_OPS,
@@ -283,29 +301,28 @@ import {
   RedisResource,
   RedisStore,
   stat
-} from "./chunk-IDYHQQOH.js";
+} from "./chunk-OSVZKYXS.js";
 import {
-  loadOptionalPeer
-} from "./chunk-E2ISWXLB.js";
+  S3Resource
+} from "./chunk-IUXXZHY3.js";
 import {
-  DatabricksVolumeResource,
-  loadDatabricksProfile,
-  parseDatabricksCfg
-} from "./chunk-RNQN2FOU.js";
+  redactConfig
+} from "./chunk-HCU3B6FW.js";
 import {
-  GCSResource,
-  GCS_PROMPT
-} from "./chunk-I5THIMPP.js";
+  GridFSAccessor,
+  GridFSResource
+} from "./chunk-CGGO5NKD.js";
 import {
-  S3Resource
-} from "./chunk-TA3WMOMU.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";
@@ -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,7 +395,6 @@ function classifyError(err) {
 }
 var MirageFS = class {
   ws;
-  agentId;
   now;
   root;
   prefixes;
@@ -385,23 +407,20 @@ var MirageFS = class {
   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(path2) {
-    if (this.root === "") return path2;
-    return path2 === "/" ? this.root : this.root + path2;
-  }
-  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 {
@@ -427,8 +446,62 @@ var MirageFS = class {
       gid: this.gid
     };
   }
-  isVirtualDir(path2) {
-    const bare = rstripSlash(path2);
+  /**
+   * 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);
@@ -436,8 +509,8 @@ var MirageFS = class {
     }
     return false;
   }
-  virtualChildren(path2) {
-    const normalized = path2 === "/" ? "/" : rstripSlash(path2) + "/";
+  virtualChildren(path4) {
+    const normalized = path4 === "/" ? "/" : rstripSlash(path4) + "/";
     const children = /* @__PURE__ */ new Set();
     for (const p of this.prefixes) {
       if (p.startsWith(normalized) && p !== normalized) {
@@ -448,47 +521,47 @@ var MirageFS = class {
     }
     return [...children].sort();
   }
-  cachedSize(path2) {
+  cachedSize(path4) {
     for (const ctx of this.handles.values()) {
-      if (ctx.path === path2 && 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(path2);
+    const entry = this.prefetchCache.get(path4);
     if (entry !== void 0 && entry.expires > Date.now()) return entry.data.byteLength;
     return null;
   }
-  cachedData(path2) {
+  cachedData(path4) {
     for (const ctx of this.handles.values()) {
-      if (ctx.path === path2 && ctx.data !== void 0) return ctx.data;
+      if (ctx.path === path4 && ctx.data !== void 0) return ctx.data;
     }
-    const entry = this.prefetchCache.get(path2);
+    const entry = this.prefetchCache.get(path4);
     if (entry !== void 0 && entry.expires > Date.now()) return entry.data;
-    if (entry !== void 0) this.prefetchCache.delete(path2);
+    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(path2) {
-    const cached = this.cachedData(path2);
+  async prefetch(path4) {
+    const cached = this.cachedData(path4);
     if (cached !== null) return cached;
-    const inflight = this.prefetchInflight.get(path2);
+    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(path2));
-        this.prefetchCache.set(path2, { 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(path2);
+        this.prefetchInflight.delete(path4);
       }
     })();
-    this.prefetchInflight.set(path2, promise);
+    this.prefetchInflight.set(path4, promise);
     return promise;
   }
   /** Drain and return accumulated op records (mirrors Python's drain_ops). */
@@ -497,12 +570,12 @@ var MirageFS = class {
     this.ws.records.length = 0;
     return records;
   }
-  async writeFile(path2, data) {
-    await this.ws.dispatch("write", this.resolve(path2), [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),
@@ -510,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),
@@ -528,58 +603,72 @@ var MirageFS = class {
       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(path2, cb) {
+  getattr(path4, cb) {
     void (async () => {
-      if (path2 === "/" || path2 === MIRAGE_DIR) {
+      if (path4 === "/") {
         cb(0, this.dirStat());
         return;
       }
-      if (path2 === MIRAGE_WHOAMI) {
-        cb(0, this.fileStat(this.whoamiContent().byteLength));
-        return;
-      }
-      const name = path2.slice(path2.lastIndexOf("/") + 1);
+      const name = path4.slice(path4.lastIndexOf("/") + 1);
       if (isMacosMetadata(name)) {
         cb(ENOENT);
         return;
       }
-      if (this.isVirtualDir(path2)) {
+      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(path2));
+        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(path2) ?? 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(path2, 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(path2, cb);
+    this.getattr(path4, cb);
   }
-  readdir(path2, cb) {
+  readdir(path4, cb) {
     void (async () => {
-      if (path2 === 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(path2));
-      if (path2 === "/") names.add(".mirage");
       try {
-        const entries = await this.ws.fs.readdir(this.resolve(path2));
+        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);
@@ -593,22 +682,15 @@ var MirageFS = class {
       cb(0, [".", "..", ...[...names].sort()]);
     })();
   }
-  read(path2, fd, buf, len, pos, cb) {
+  read(path4, fd, buf, len, pos, cb) {
     void (async () => {
-      if (path2 === 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(path2);
-          ctx.data = cached ?? await this.ws.fs.readFile(this.resolve(path2));
+          const cached = this.cachedData(path4);
+          ctx.data = cached ?? await this.ws.fs.readFile(this.resolve(path4));
         }
-        const data = ctx?.data ?? this.cachedData(path2) ?? await this.ws.fs.readFile(this.resolve(path2));
+        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);
@@ -617,7 +699,7 @@ var MirageFS = class {
       }
     })();
   }
-  write(path2, 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) {
@@ -630,7 +712,7 @@ var MirageFS = class {
       try {
         let existing = new Uint8Array(0);
         try {
-          existing = await this.ws.fs.readFile(this.resolve(path2), { raw: true });
+          existing = await this.ws.fs.readFile(this.resolve(path4), { raw: true });
         } catch {
         }
         let merged = existing;
@@ -649,46 +731,84 @@ var MirageFS = class {
           }
           merged = out;
         }
-        await this.writeFile(path2, merged);
+        await this.writeFile(path4, merged);
         cb(len);
       } catch {
         cb(0);
       }
     })();
   }
-  create(path2, _mode, cb) {
+  create(path4, _mode, cb) {
     void (async () => {
       try {
         try {
-          await this.ws.dispatch("create", this.resolve(path2));
+          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(path2, 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: path2 });
+        this.handles.set(fh, { path: path4 });
         cb(0, fh);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  mkdir(path2, _mode, cb) {
+  mkdir(path4, _mode, cb) {
     void (async () => {
       try {
-        await this.ws.fs.mkdir(this.resolve(path2));
+        await this.ws.dispatch("mkdir", this.resolve(path4));
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  unlink(path2, 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 this.ws.fs.unlink(this.resolve(path2));
-        this.xattrs.delete(path2);
+        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.dispatch("unlink", this.resolve(path4));
+        this.xattrs.delete(path4);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
@@ -698,7 +818,9 @@ 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);
@@ -710,37 +832,36 @@ var MirageFS = class {
       }
     })();
   }
-  rmdir(path2, cb) {
+  rmdir(path4, cb) {
     void (async () => {
       try {
         try {
-          const entries = await this.ws.fs.readdir(this.resolve(path2));
+          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(path2));
-        this.xattrs.delete(path2);
+        await this.ws.dispatch("rmdir", this.resolve(path4));
+        this.xattrs.delete(path4);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  truncate(path2, size, cb) {
+  truncate(path4, size, cb) {
     void (async () => {
       try {
         try {
-          await this.ws.dispatch("truncate", this.resolve(path2), [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(path2), { 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(path2, out);
+          await this.writeFile(path4, out);
         }
         cb(0);
       } catch (err) {
@@ -764,17 +885,17 @@ 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(path2, _mode, cb) {
-    this.getattrValidate(path2, cb);
+  chmod(path4, _mode, cb) {
+    this.getattrValidate(path4, cb);
   }
-  chown(path2, _uid, _gid, cb) {
-    this.getattrValidate(path2, cb);
+  chown(path4, _uid, _gid, cb) {
+    this.getattrValidate(path4, cb);
   }
-  utimens(path2, _atime, _mtime, cb) {
-    this.getattrValidate(path2, cb);
+  utimens(path4, _atime, _mtime, cb) {
+    this.getattrValidate(path4, cb);
   }
-  access(path2, _amode, cb) {
-    this.getattrValidate(path2, 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
@@ -782,68 +903,62 @@ var MirageFS = class {
   // Finder writing com.apple.*) succeed instead of failing with ENOTSUP. The
   // values live only for the mount's lifetime and are never written to the
   // backend.
-  setxattr(path2, name, value, _position, _flags, cb) {
-    this.getattr(path2, (code) => {
+  setxattr(path4, name, value, _position, _flags, cb) {
+    this.getattr(path4, (code) => {
       if (code !== 0) {
         cb(code);
         return;
       }
-      let attrs = this.xattrs.get(path2);
+      let attrs = this.xattrs.get(path4);
       if (attrs === void 0) {
         attrs = /* @__PURE__ */ new Map();
-        this.xattrs.set(path2, attrs);
+        this.xattrs.set(path4, attrs);
       }
       attrs.set(name, Buffer.from(value));
       cb(0);
     });
   }
-  getxattr(path2, name, _position, cb) {
-    this.getattr(path2, (code) => {
+  getxattr(path4, name, _position, cb) {
+    this.getattr(path4, (code) => {
       if (code !== 0) {
         cb(code);
         return;
       }
-      cb(0, this.xattrs.get(path2)?.get(name));
+      cb(0, this.xattrs.get(path4)?.get(name));
     });
   }
-  listxattr(path2, cb) {
-    this.getattr(path2, (code) => {
+  listxattr(path4, cb) {
+    this.getattr(path4, (code) => {
       if (code !== 0) {
         cb(code);
         return;
       }
-      const attrs = this.xattrs.get(path2);
+      const attrs = this.xattrs.get(path4);
       cb(0, attrs ? [...attrs.keys()] : []);
     });
   }
-  removexattr(path2, name, cb) {
-    this.getattr(path2, (code) => {
+  removexattr(path4, name, cb) {
+    this.getattr(path4, (code) => {
       if (code !== 0) {
         cb(code);
         return;
       }
-      this.xattrs.get(path2)?.delete(name);
+      this.xattrs.get(path4)?.delete(name);
       cb(0);
     });
   }
-  getattrValidate(path2, cb) {
-    this.getattr(path2, (code) => {
+  getattrValidate(path4, cb) {
+    this.getattr(path4, (code) => {
       cb(code);
     });
   }
-  open(path2, _flags, cb) {
+  open(path4, _flags, cb) {
     void (async () => {
-      if (path2 === MIRAGE_WHOAMI) {
-        const fh = this.nextFh++;
-        this.handles.set(fh, { path: path2 });
-        cb(0, fh);
-        return;
-      }
       try {
-        const s = await this.ws.fs.stat(this.resolve(path2));
-        const ctx = { path: path2 };
+        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(path2);
+          const data = await this.prefetch(path4);
           if (data !== null) ctx.data = data;
         }
         const fh = this.nextFh++;
@@ -858,7 +973,7 @@ var MirageFS = class {
     this.handles.delete(fd);
     cb(0);
   }
-  flush(path2, fd, cb) {
+  flush(path4, fd, cb) {
     const ctx = this.handles.get(fd);
     if (ctx?.writeBuf === void 0 || ctx.writeBuf.length === 0) {
       cb(0);
@@ -870,7 +985,7 @@ var MirageFS = class {
       try {
         let existing = new Uint8Array(0);
         try {
-          existing = await this.ws.fs.readFile(this.resolve(path2), { raw: true });
+          existing = await this.ws.fs.readFile(this.resolve(path4), { raw: true });
         } catch {
         }
         let total = existing.byteLength;
@@ -882,19 +997,32 @@ var MirageFS = class {
         for (const [off, chunk] of writes) {
           merged.set(chunk, off);
         }
-        await this.writeFile(path2, merged);
+        await this.writeFile(path4, merged);
         cb(0);
       } catch (err) {
         cb(classifyError(err));
       }
     })();
   }
-  fsync(path2, _datasync, fd, cb) {
-    this.flush(path2, 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"),
@@ -931,10 +1059,9 @@ async function mount(ws, options = {}) {
     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 = {
@@ -945,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();
@@ -1103,27 +1231,24 @@ var Workspace = class extends CoreWorkspace {
   fuseMountpointsMap = /* @__PURE__ */ new Map();
   fuseManagers = /* @__PURE__ */ new Map();
   constructor(resources, options = {}) {
-    const bareResources = {};
-    const modeOverrides = { ...options.modeOverrides ?? {} };
+    const specs = {};
     const commandSafeguards = {
       ...options.commandSafeguards ?? {}
     };
     const fuseTargets = [];
     for (const [prefix, value] of Object.entries(resources)) {
       if (value instanceof Mount) {
-        bareResources[prefix] = value.resource;
-        if (value.options.mode !== void 0) modeOverrides[prefix] = value.options.mode;
+        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 {
-        bareResources[prefix] = value;
+        specs[prefix] = value;
       }
     }
-    super(bareResources, {
+    super(specs, {
       ...options,
-      ...Object.keys(modeOverrides).length > 0 ? { modeOverrides } : {},
       ...Object.keys(commandSafeguards).length > 0 ? { commandSafeguards } : {},
       shellParserFactory: options.shellParserFactory ?? loadShellParser
     });
@@ -1157,29 +1282,38 @@ var Workspace = class extends CoreWorkspace {
    * 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) {
-    if (mountpoint !== void 0) this.registerFuseMount(prefix, mountpoint);
+  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(prefix, fm);
+    this.fuseManagers.set(key, fm);
     try {
       const mp = await fm.setup(this, {
         rootPrefix: prefix,
-        ...mountpoint !== void 0 ? { mountpoint } : {}
+        ...mountpoint !== void 0 ? { mountpoint } : {},
+        ...session !== void 0 ? { session } : {}
       });
-      if (mountpoint === void 0) this.registerFuseMount(prefix, mp);
+      if (mountpoint === void 0) this.registerFuseMount(key, mp);
       return mp;
     } catch (err) {
-      this.fuseManagers.delete(prefix);
-      this.fuseMountpointsMap.delete(prefix);
+      this.fuseManagers.delete(key);
+      this.fuseMountpointsMap.delete(key);
       throw err;
     }
   }
-  async removeFuseMount(prefix) {
-    const fm = this.fuseManagers.get(prefix);
-    this.fuseManagers.delete(prefix);
+  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(prefix);
+    this.fuseMountpointsMap.delete(key);
   }
   get fuseMountpoints() {
     return Object.fromEntries(this.fuseMountpointsMap);
@@ -1347,11 +1481,634 @@ var RedisObserverStore = class {
   }
   async close() {
     if (this.clientPromise === null) return;
-    const c = await this.clientPromise;
+    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 createRequire3 } from "module";
@@ -1362,7 +2119,10 @@ 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;
   }
@@ -1509,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);
@@ -1577,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",
@@ -1594,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;
   }
@@ -1633,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}`);
@@ -1640,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;
   }
@@ -1651,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 = [];
@@ -1831,208 +2608,218 @@ var REGISTRY = {
     return new RAMResource();
   },
   disk: async (config) => {
-    const { DiskResource: DiskResource2 } = await import("./disk-XVLBCVKE.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-V5ULXULL.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-4OIOCAAT.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-EMEYU2XT.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-ZLVECXTW.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-RPK25ANI.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-DTKXKKFF.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-55C4APKR.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-RO5JR36V.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-ZVZ3EDRX.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-6CFTOKGZ.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-7XOUYSTY.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-HZ576XFQ.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-S2VOYO6G.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-QSWKF2FN.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-6Z4DC5S5.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-TDFD23QO.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-3CQ4CPPZ.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-IWZZOSQ4.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-JMJ3PFYY.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-CCWCLUHB.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-YLP6K3L4.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-P36Z2YN4.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-JVR62OIO.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-YPS7PII3.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-YFP3SMTJ.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-BG7OSRJG.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-XYKWZD6P.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-IC37LZV7.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-HKRPQMJS.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-ACASJZ7O.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-DV7E6OFV.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-Q554V5PA.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-R67TDPON.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-H4RYMQJ5.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-YLCHKJOM.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-PRN2ALRK.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-74GYLV3R.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-GQ2U2R6R.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-OLN2LT4O.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-5IZ7OBQ4.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));
   }
 };
@@ -2059,6 +2846,7 @@ export {
   BoxResource,
   CEPH_PROMPT,
   CephResource,
+  DEFAULT_STATE_ROOT,
   DIGITALOCEAN_PROMPT,
   DISK_COMMANDS,
   DISK_OPS,
@@ -2066,8 +2854,12 @@ export {
   DatabricksVolumeResource,
   DigitalOceanResource,
   DiscordResource,
+  DiskNamespaceStore,
   DiskObserverStore,
+  DiskRecordClient,
   DiskResource,
+  DiskSessionStore,
+  DiskWorkspaceStateStore,
   DropboxResource,
   EMAIL_COMMANDS,
   EMAIL_OPS,
@@ -2086,6 +2878,8 @@ export {
   GitHubCIResource,
   GitHubResource,
   GmailResource,
+  GridFSAccessor,
+  GridFSResource,
   HF_BUCKETS_PROMPT,
   HF_COMMANDS,
   HF_DATASETS_PROMPT,
@@ -2113,6 +2907,11 @@ export {
   MongoDBResource,
   MongoDBStore,
   Mount,
+  NEXTCLOUD_COMMANDS,
+  NEXTCLOUD_OPS,
+  NEXTCLOUD_PROMPT,
+  NextcloudAccessor,
+  NextcloudResource,
   NotionResource,
   OCIResource,
   OCI_PROMPT,
@@ -2127,9 +2926,12 @@ export {
   REDIS_PROMPT,
   RedisAccessor,
   RedisFileCacheStore,
+  RedisNamespaceStore,
   RedisObserverStore,
   RedisResource,
+  RedisSessionStore,
   RedisStore,
+  RedisWorkspaceStateStore,
   S3Resource,
   SCALEWAY_PROMPT,
   SEAWEEDFS_PROMPT,
@@ -2171,11 +2973,13 @@ export {
   normalizeGitHubCIConfig,
   normalizeGitHubConfig,
   normalizeGoogleConfig as normalizeGmailConfig,
+  normalizeGridFSConfig,
   normalizeHfBucketsConfig,
   normalizeHfModelsConfig,
   normalizeHfRepoConfig,
   normalizeLangfuseConfig,
   normalizeLinearConfig,
+  normalizeNextcloudConfig,
   normalizeNotionConfig,
   normalizeSlackConfig,
   normalizeSshConfig,
@@ -2204,6 +3008,7 @@ export {
   redactLangfuseConfig,
   redactLinearConfig,
   redactMinIOConfig,
+  redactNextcloudConfig,
   redactNotionConfig,
   redactOciConfig,
   redactQingStorConfig,