@struktoai/mirage-node 0.0.4 → 0.0.5-alpha.1

package/dist/index.js

@@ -1,234 +1,244 @@
-import {
-  DropboxResource
-} from "./chunk-HWQPEBID.js";
 import {
   BoxResource
-} from "./chunk-BWLUBJQG.js";
+} from "./chunk-JXOMDLFS.js";
 import {
   normalizeBoxConfig,
   redactBoxConfig
-} from "./chunk-XFSEADPC.js";
+} from "./chunk-L42UTDFK.js";
 import {
   GmailResource
-} from "./chunk-CB76WPUS.js";
+} from "./chunk-BYCUGFRF.js";
 import {
-  normalizeGoogleConfig,
-  redactGoogleConfig
+  normalizeGoogleConfig as normalizeGoogleConfig5,
+  redactGoogleConfig as redactGoogleConfig5
 } from "./chunk-LPDLPRPS.js";
+import {
+  GCalResource
+} from "./chunk-DQIEWEAW.js";
+import {
+  normalizeGoogleConfig as normalizeGoogleConfig6,
+  redactGoogleConfig as redactGoogleConfig6
+} from "./chunk-ZTHVEXIV.js";
 import {
   EMAIL_COMMANDS,
   EMAIL_OPS,
   EMAIL_PROMPT,
   EMAIL_WRITE_PROMPT,
   EmailAccessor,
-  EmailResource
-} from "./chunk-4GYB7DGC.js";
+  EmailResource,
+  fetchHeaders,
+  fetchMessage,
+  fetchRawMessage,
+  listFolderEntries,
+  listMessageUids,
+  messageJsonBytes,
+  messagesJsonBytes,
+  parseRfc822
+} from "./chunk-TWRQCQWU.js";
 import {
+  EmailConfigSchema,
   buildEmailConfig,
   normalizeEmailConfig,
   redactEmailConfig
-} from "./chunk-CQCTCW4S.js";
-import {
-  GDocsResource
-} from "./chunk-JEBH5APX.js";
+} from "./chunk-CRC4YWXB.js";
 import {
   GSheetsResource
-} from "./chunk-SAOQW6ZJ.js";
+} from "./chunk-GSGE3M5P.js";
 import {
-  normalizeGSheetsConfig,
-  redactGSheetsConfig
-} from "./chunk-D3U7VQCG.js";
+  normalizeGoogleConfig as normalizeGoogleConfig2,
+  redactGoogleConfig as redactGoogleConfig2
+} from "./chunk-M2UF2JHJ.js";
 import {
   GSlidesResource
-} from "./chunk-YRJICL2Q.js";
+} from "./chunk-PKNE5J2B.js";
 import {
-  normalizeGSlidesConfig,
-  redactGSlidesConfig
-} from "./chunk-GTAS3QVC.js";
+  normalizeGoogleConfig as normalizeGoogleConfig3,
+  redactGoogleConfig as redactGoogleConfig3
+} from "./chunk-4IF4TGAI.js";
 import {
   GDriveResource
-} from "./chunk-VLRSOWHP.js";
+} from "./chunk-2A4YGVBM.js";
+import {
+  normalizeGoogleConfig as normalizeGoogleConfig4,
+  redactGoogleConfig as redactGoogleConfig4
+} from "./chunk-IZMKMD3O.js";
 import {
-  normalizeGDriveConfig,
-  redactGDriveConfig
-} from "./chunk-KGC2OGXI.js";
+  DropboxResource
+} from "./chunk-ADEXNSYU.js";
 import {
   normalizeDropboxConfig,
   redactDropboxConfig
-} from "./chunk-HSD24IP2.js";
-import {
-  NotionResource
-} from "./chunk-SI4GMRXD.js";
+} from "./chunk-DCDBIXVZ.js";
 import {
-  LangfuseResource
-} from "./chunk-M6E7VK4D.js";
-import {
-  normalizeLangfuseConfig,
-  redactLangfuseConfig
-} from "./chunk-AULFV3KY.js";
+  JaegerResource
+} from "./chunk-YKRQSZS7.js";
+import "./chunk-2HCYLVGY.js";
 import {
   GitHubResource
-} from "./chunk-5YRWF5RP.js";
+} from "./chunk-WY4FNH42.js";
 import {
   normalizeGitHubConfig,
   redactGitHubConfig
-} from "./chunk-XUUSWR4U.js";
+} from "./chunk-FFH6R5VQ.js";
 import {
   GitHubCIResource
-} from "./chunk-JBDFYIN2.js";
+} from "./chunk-OHKGIQB4.js";
 import {
   normalizeGitHubCIConfig,
   redactGitHubCIConfig
-} from "./chunk-ZPB3SLPK.js";
+} from "./chunk-ND4IWJ4V.js";
+import {
+  GDocsResource
+} from "./chunk-GE6H2COM.js";
 import {
-  normalizeGDocsConfig,
-  redactGDocsConfig
-} from "./chunk-JHI2PHHD.js";
+  normalizeGoogleConfig,
+  redactGoogleConfig
+} from "./chunk-XJBC3OYX.js";
 import {
   NEXTCLOUD_COMMANDS,
   NEXTCLOUD_OPS,
   NEXTCLOUD_PROMPT,
   NextcloudAccessor,
-  NextcloudResource
-} from "./chunk-ZPZQXHW2.js";
+  NextcloudResource,
+  NextcloudWalk,
+  buildDeltaHook
+} from "./chunk-NZ3EKGW4.js";
 import {
   DiscordResource
-} from "./chunk-RHUEV4I7.js";
-import {
-  normalizeDiscordConfig,
-  redactDiscordConfig
-} from "./chunk-EVK6HH6Z.js";
+} from "./chunk-EIUTZ6N7.js";
 import {
   TrelloResource
-} from "./chunk-3JZN3GYO.js";
+} from "./chunk-QYLVMC6B.js";
 import {
   normalizeTrelloConfig,
   redactTrelloConfig
-} from "./chunk-NJ42VNXG.js";
+} from "./chunk-ATLXMNKD.js";
 import {
   LinearResource
-} from "./chunk-ZMREYTHA.js";
+} from "./chunk-XPRDXWK7.js";
 import {
-  normalizeLinearConfig,
-  redactLinearConfig
-} from "./chunk-IKJQOYI4.js";
+  NotionResource
+} from "./chunk-7JYHFXXC.js";
 import {
-  normalizeNotionConfig,
-  redactNotionConfig
-} from "./chunk-VIICUPWQ.js";
+  LangfuseResource
+} from "./chunk-JQR4HVUX.js";
+import {
+  normalizeLangfuseConfig,
+  redactLangfuseConfig
+} from "./chunk-IFUCGI4I.js";
 import {
   QINGSTOR_PROMPT,
   QingStorResource
-} from "./chunk-5I7Q7RHW.js";
+} from "./chunk-TUF7TCN7.js";
 import {
   PostgresResource,
   PostgresStore
-} from "./chunk-VHED2STW.js";
+} from "./chunk-ZVSYUCYS.js";
 import {
   MongoDBResource,
   MongoDBStore
-} from "./chunk-FRGTDZQT.js";
+} from "./chunk-H64SB6VO.js";
 import {
-  SlackResource
-} from "./chunk-IEVLWEBO.js";
+  LanceDBResource,
+  LanceDBStore
+} from "./chunk-HS24BL6W.js";
 import {
-  normalizeSlackConfig,
-  redactSlackConfig
-} from "./chunk-IEHPTILN.js";
+  SlackResource
+} from "./chunk-YMBL3VJB.js";
 import {
   SSHAccessor,
   SSHResource,
   SSH_COMMANDS,
   SSH_OPS,
   SSH_PROMPT
-} from "./chunk-5ZHNPNDD.js";
+} from "./chunk-KIX6N7NT.js";
 import {
   normalizeSshConfig,
   redactSshConfig
-} from "./chunk-LPLZLSMK.js";
+} from "./chunk-MONC734W.js";
 import {
   normalizeNextcloudConfig,
   redactNextcloudConfig
-} from "./chunk-MRXTUFBZ.js";
+} from "./chunk-RYQJJB4C.js";
 import {
   DIGITALOCEAN_PROMPT,
   DigitalOceanResource
-} from "./chunk-CXQGMFI7.js";
+} from "./chunk-RX3XR65X.js";
 import {
   TENCENT_PROMPT,
   TencentResource
-} from "./chunk-EGZNOUMH.js";
+} from "./chunk-FA6YNU75.js";
 import {
   redactTencentConfig,
   resolvedTencentEndpoint
-} from "./chunk-WTSSEUOZ.js";
+} from "./chunk-2VPZAH5Q.js";
 import {
   ALIYUN_PROMPT,
   AliyunResource
-} from "./chunk-XEMLYWHK.js";
+} from "./chunk-I7CPLZNW.js";
 import {
   redactAliyunConfig,
   resolvedAliyunEndpoint
-} from "./chunk-2QNPKPZZ.js";
+} from "./chunk-U6DFQRG3.js";
 import {
   SCALEWAY_PROMPT,
   ScalewayResource
-} from "./chunk-L4GMDSMB.js";
+} from "./chunk-6SVXWRKX.js";
 import {
   redactScalewayConfig,
   resolvedScalewayEndpoint
-} from "./chunk-YBVMZ7SR.js";
+} from "./chunk-7VQQFWV6.js";
 import {
   redactQingStorConfig,
   resolvedQingStorEndpoint
-} from "./chunk-WWP2STF5.js";
+} from "./chunk-IXA4DQE4.js";
 import {
   SEAWEEDFS_PROMPT,
   SeaweedFSResource
-} from "./chunk-NLXJMXVE.js";
+} from "./chunk-TUX36JY5.js";
 import {
   CEPH_PROMPT,
   CephResource
-} from "./chunk-XADEMW6B.js";
+} from "./chunk-N72RLCMU.js";
 import {
   redactCephConfig
-} from "./chunk-UYA3XL3J.js";
+} from "./chunk-PSXXEGYQ.js";
 import {
   WASABI_PROMPT,
   WasabiResource
-} from "./chunk-L7FEZ7LU.js";
+} from "./chunk-5H6KNEPP.js";
 import {
   redactWasabiConfig,
   resolvedWasabiEndpoint
-} from "./chunk-S4KVLPBR.js";
+} from "./chunk-YZ4ZJNOL.js";
 import {
   BACKBLAZE_PROMPT,
   BackblazeResource
-} from "./chunk-SYMNWNC3.js";
+} from "./chunk-QQ7FP4GD.js";
 import {
   redactBackblazeConfig,
   resolvedBackblazeEndpoint
-} from "./chunk-UAJYJP5C.js";
+} from "./chunk-EUPXAYPB.js";
 import {
   redactDigitalOceanConfig,
   resolvedDigitalOceanEndpoint
-} from "./chunk-3ASOQTZB.js";
+} from "./chunk-VI5YTKNY.js";
 import {
   HF_BUCKETS_PROMPT,
   HfBucketsResource
-} from "./chunk-4M73WHIE.js";
+} from "./chunk-BZTVYOES.js";
 import {
   HF_DATASETS_PROMPT,
   HfDatasetsResource
-} from "./chunk-DXU7NZPH.js";
+} from "./chunk-HCRYAFBI.js";
 import {
   HF_MODELS_PROMPT,
   HfModelsResource
-} from "./chunk-V7JVMG63.js";
+} from "./chunk-OXEQSPND.js";
 import {
   HF_SPACES_PROMPT,
   HfSpacesResource
-} from "./chunk-BWWU5T2D.js";
+} from "./chunk-ENW5BVYN.js";
 import {
   HF_COMMANDS,
   HF_OPS,
@@ -238,7 +248,7 @@ import {
   HfDatasetsAccessor,
   HfModelsAccessor,
   HfSpacesAccessor
-} from "./chunk-HEDE2377.js";
+} from "./chunk-DDAFNROK.js";
 import {
   HF_ENDPOINT,
   assertHfRepoId,
@@ -246,53 +256,54 @@ import {
   normalizeHfRepoConfig,
   redactHfBucketsConfig,
   redactHfRepoConfig
-} from "./chunk-KAWDDS27.js";
+} from "./chunk-QAOVABCR.js";
 import {
   MINIO_PROMPT,
   MinIOResource
-} from "./chunk-4X6CLF4F.js";
+} from "./chunk-JJERW2BI.js";
 import {
   redactMinIOConfig
-} from "./chunk-GF75O2EN.js";
+} from "./chunk-HVYVG5KQ.js";
 import {
   redactSeaweedFSConfig
-} from "./chunk-MIQ3ECZM.js";
+} from "./chunk-AQSYAXL4.js";
+import "./chunk-7ZP6TPHX.js";
 import {
   GCSResource,
   GCS_PROMPT
-} from "./chunk-25W4XQJZ.js";
+} from "./chunk-5K2MWDCE.js";
 import {
   GCS_ENDPOINT,
   redactGcsConfig
-} from "./chunk-E3KXVEYI.js";
+} from "./chunk-OAE57MNL.js";
 import {
   OCIResource,
   OCI_PROMPT
-} from "./chunk-TUNR4VUM.js";
+} from "./chunk-GMMQ3ZK4.js";
 import {
   redactOciConfig
-} from "./chunk-H62XQZUM.js";
+} from "./chunk-6VOIUGAD.js";
 import {
   R2Resource,
   R2_PROMPT
-} from "./chunk-ZM44MGC5.js";
+} from "./chunk-WMJJ4WGF.js";
 import {
   redactR2Config
-} from "./chunk-VBYIDRNU.js";
+} from "./chunk-XIG5BWWH.js";
 import {
   SUPABASE_PROMPT,
   SupabaseResource
-} from "./chunk-F5NWRF32.js";
+} from "./chunk-ETIAW4YD.js";
 import {
   redactSupabaseConfig,
   resolvedSupabaseEndpoint
-} from "./chunk-2ERLWAGG.js";
+} from "./chunk-EBI4IHDC.js";
 import {
   DISK_COMMANDS,
   DISK_OPS,
   DISK_PROMPT,
   DiskResource
-} from "./chunk-W5ZLIQFR.js";
+} from "./chunk-WG5YS6TC.js";
 import {
   REDIS_COMMANDS,
   REDIS_OPS,
@@ -301,28 +312,30 @@ import {
   RedisResource,
   RedisStore,
   stat
-} from "./chunk-OSVZKYXS.js";
+} from "./chunk-HOPUP6LA.js";
 import {
   S3Resource
-} from "./chunk-IUXXZHY3.js";
+} from "./chunk-EJZG5VUF.js";
 import {
+  normalizeS3Config,
   redactConfig
-} from "./chunk-HCU3B6FW.js";
+} from "./chunk-3JZQ6VSZ.js";
 import {
+  GRIDFS_COMMANDS,
   GridFSAccessor,
   GridFSResource
-} from "./chunk-CGGO5NKD.js";
+} from "./chunk-YUJBXFYK.js";
 import {
   loadOptionalPeer
 } from "./chunk-OQKNDS66.js";
 import {
   normalizeGridFSConfig
-} from "./chunk-C7TNKIK5.js";
+} from "./chunk-CTGXJHO5.js";
 import {
   DatabricksVolumeResource,
   loadDatabricksProfile,
   parseDatabricksCfg
-} from "./chunk-HGIPWY5Y.js";
+} from "./chunk-IFYXSSKR.js";
 
 // src/index.ts
 export * from "@struktoai/mirage-core";
@@ -332,6 +345,8 @@ import { readFileSync } from "fs";
 import { createRequire as createRequire2 } from "module";
 import {
   createShellParser,
+  KERNEL_BACKENDS as KERNEL_BACKENDS2,
+  MountBackend as MountBackend3,
   Workspace as CoreWorkspace
 } from "@struktoai/mirage-core";
 
@@ -340,20 +355,191 @@ import { rmdirSync } from "fs";
 
 // src/fuse/mount.ts
 import { execSync } from "child_process";
+import { randomBytes } from "crypto";
 import { mkdirSync, mkdtempSync } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
+import { basename, join } from "path";
+import { MountBackend as MountBackend2 } from "@struktoai/mirage-core";
 
-// src/fuse/fs.ts
+// src/fuse/backend.ts
 import { posix } from "path";
 import {
+  KERNEL_BACKENDS,
+  MountBackend,
+  MountMode,
+  rstripSlash,
+  sizesAlwaysKnown
+} from "@struktoai/mirage-core";
+var FSKIT_MOUNT_ROOT = "/Volumes";
+function resolveBackend(value) {
+  if (value === void 0 || value === null || value === "") return MountBackend.VFS;
+  const lowered = value.toLowerCase();
+  if (!Object.values(MountBackend).includes(lowered)) {
+    throw new Error(
+      `unknown mount backend ${JSON.stringify(value)}; expected one of: ${Object.values(
+        MountBackend
+      ).join(", ")}`
+    );
+  }
+  return lowered;
+}
+function requireKernelBackend(backend) {
+  if (!KERNEL_BACKENDS.includes(backend)) {
+    throw new Error(
+      `backend ${JSON.stringify(backend)} does not register a mountpoint; it is served inside mirage's own filesystem, so there is nothing to mount`
+    );
+  }
+}
+function checkPlatform(backend) {
+  if (backend !== MountBackend.FSKIT) return;
+  if (process.platform !== "darwin") {
+    throw new Error(
+      `the fskit mount backend is macOS-only (running on ${process.platform}); use backend 'fuse'`
+    );
+  }
+}
+function checkMountpoint(backend, mountpoint) {
+  if (backend !== MountBackend.FSKIT) return;
+  const resolved = posix.normalize(mountpoint);
+  if (resolved !== FSKIT_MOUNT_ROOT && !resolved.startsWith(FSKIT_MOUNT_ROOT + "/")) {
+    throw new Error(
+      `the fskit mount backend only mounts under ${FSKIT_MOUNT_ROOT}; got ${JSON.stringify(mountpoint)}`
+    );
+  }
+}
+function unsizedMounts(ws, rootPrefix = "") {
+  const root = rstripSlash(rootPrefix);
+  const found = [];
+  for (const m of ws.mounts()) {
+    const bare = rstripSlash(m.prefix);
+    if (root !== "" && bare !== root && !m.prefix.startsWith(root + "/")) continue;
+    if (!sizesAlwaysKnown(m.resource)) found.push([m.prefix, m.resource.kind]);
+  }
+  return found;
+}
+function checkSizes(backend, ws, rootPrefix = "") {
+  if (backend !== MountBackend.FSKIT) return;
+  const offenders = unsizedMounts(ws, rootPrefix);
+  if (offenders.length === 0) return;
+  const listed = offenders.map(([prefix, kind]) => `${prefix} (${kind})`).join(", ");
+  console.warn(
+    `mirage: the fskit mount backend cannot serve resources whose file sizes are only known after a read; size-unknown files under these mounts will read as empty: ${listed}. Mount them with backend 'fuse', or scope the fskit mount to a byte-store resource (ram, disk, redis, s3, gridfs).`
+  );
+}
+function writableMounts(ws, rootPrefix = "") {
+  const root = rstripSlash(rootPrefix);
+  const found = [];
+  for (const m of ws.mounts()) {
+    const bare = rstripSlash(m.prefix);
+    if (root !== "" && bare !== root && !m.prefix.startsWith(root + "/")) continue;
+    if (m.mode !== MountMode.READ) found.push([m.prefix, m.resource.kind]);
+  }
+  return found;
+}
+function checkWrites(backend, ws, rootPrefix = "") {
+  if (backend !== MountBackend.FSKIT) return;
+  const offenders = writableMounts(ws, rootPrefix).filter(
+    ([prefix]) => rstripSlash(prefix) !== "/dev"
+  );
+  if (offenders.length === 0) return;
+  const listed = offenders.map(([prefix, kind]) => `${prefix} (${kind})`).join(", ");
+  console.warn(
+    `mirage: file data written through an fskit mount may be flushed by the macFUSE FSKit shim as zeroed pages (metadata ops are reliable; the writer sees no error): ${listed}. Mount them read-only, or use backend 'fuse' for writes.`
+  );
+}
+function prepareBackend(value, ws, mountpoint, rootPrefix = "") {
+  const backend = resolveBackend(value);
+  requireKernelBackend(backend);
+  checkPlatform(backend);
+  if (mountpoint !== void 0) checkMountpoint(backend, mountpoint);
+  if (ws !== void 0) {
+    checkSizes(backend, ws, rootPrefix);
+    checkWrites(backend, ws, rootPrefix);
+  }
+  return backend;
+}
+
+// src/fuse/fs.ts
+import { runWithSession } from "@struktoai/mirage-core";
+
+// src/fuse/core.ts
+import { posix as posix2 } from "path";
+import {
+  DIR_MODE,
+  FILE_MODE,
+  FileTable,
   FileType,
   isMissingOp,
-  PathSpec,
-  runWithSession,
-  rstripSlash
+  mergeWrites,
+  mtimeMs,
+  rstripSlash as rstripSlash2,
+  compareCodePoints
 } from "@struktoai/mirage-core";
 
+// src/fuse/errors.ts
+import { constants as osConstants } from "os";
+import { classify } from "@struktoai/mirage-core";
+var ENOENT = 2;
+var EIO = 5;
+var EACCES = 13;
+var EEXIST = 17;
+var EINVAL = 22;
+var ENOTDIR = 20;
+var EISDIR = 21;
+var EROFS = 30;
+var ENOTEMPTY = 66;
+var EXDEV = 18;
+var CONDITION_ERRNO = {
+  ENOENT,
+  ENOTDIR,
+  EISDIR,
+  EEXIST,
+  EACCES,
+  EPERM: osConstants.errno.EPERM,
+  ENOTEMPTY,
+  EXDEV,
+  CROSS_MOUNT: EXDEV,
+  ENOTSUP: osConstants.errno.ENOTSUP,
+  ELOOP: osConstants.errno.ELOOP,
+  EINVAL,
+  EIO,
+  EBUSY: osConstants.errno.EBUSY,
+  EROFS,
+  NO_XATTR: osConstants.errno.ENODATA
+};
+var MESSAGE_ERRNO = [
+  [["not empty", "enotempty"], ENOTEMPTY],
+  [["not a directory", "enotdir"], ENOTDIR],
+  [["is a directory", "eisdir"], EISDIR],
+  // A session capability rejection (MountNotAllowedError) is a permission
+  // failure, mirroring Python's PermissionError -> EACCES.
+  [["not allowed to access mount"], EACCES],
+  [["permission", "eacces", "read-only"], EACCES],
+  [["file exists", "eexist"], EEXIST],
+  [["not found", "no such", "enoent", "no mount"], ENOENT]
+];
+function classifyErrno(err) {
+  const condition = classify(err);
+  if (condition !== null) return CONDITION_ERRNO[condition];
+  const code = err.code;
+  if (code !== void 0) {
+    const errnos = osConstants.errno;
+    const passthrough = errnos[code];
+    if (passthrough !== void 0) return passthrough;
+  }
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  for (const [needles, errno] of MESSAGE_ERRNO) {
+    if (needles.some((n) => msg.includes(n))) return errno;
+  }
+  return EIO;
+}
+function classifyError(err) {
+  return -classifyErrno(err);
+}
+function errnoError(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+
 // src/fuse/platform/macos.ts
 var MACOS_METADATA = /* @__PURE__ */ new Set([
   ".DS_Store",
@@ -365,54 +551,25 @@ function isMacosMetadata(name) {
   return MACOS_METADATA.has(name) || name.startsWith("._");
 }
 
-// src/fuse/fs.ts
-var ENOENT = -2;
-var EACCES = -13;
-var ENOTDIR = -20;
-var EEXIST = -17;
-var ENOTEMPTY = -66;
-var EIO = -5;
-var EINVAL = -22;
-var EROFS = -30;
+// src/fuse/core.ts
 var PREFETCH_TTL_MS = 3e4;
-function classifyError(err) {
-  const code = err.code;
-  if (code === "ENOTEMPTY") return ENOTEMPTY;
-  if (code === "ENOTDIR") return ENOTDIR;
-  if (code === "EACCES") return EACCES;
-  if (code === "EEXIST") return EEXIST;
-  if (code === "ENOENT") return ENOENT;
-  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;
-  if (msg.includes("not found") || msg.includes("no such") || msg.includes("enoent") || msg.includes("no mount"))
-    return ENOENT;
-  return EIO;
-}
-var MirageFS = class {
-  ws;
+var MountCore = class {
+  ops;
+  session;
   now;
   root;
-  prefixes;
-  handles = /* @__PURE__ */ new Map();
-  // In-memory extended attributes, keyed by FUSE path. Backends have no POSIX
+  handles = new FileTable();
+  // In-memory extended attributes, keyed by 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;
+  constructor(ops, options = {}) {
+    this.ops = ops;
     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.root = options.rootPrefix !== void 0 ? rstripSlash2(options.rootPrefix) : "";
     this.uid = typeof process.getuid === "function" ? process.getuid() : 0;
     this.gid = typeof process.getgid === "function" ? process.getgid() : 0;
     this.session = options.session ?? null;
@@ -429,7 +586,7 @@ var MirageFS = class {
       ctime: this.now,
       nlink: 2,
       size: 0,
-      mode: 16877,
+      mode: DIR_MODE,
       uid: this.uid,
       gid: this.gid
     };
@@ -441,17 +598,17 @@ var MirageFS = class {
       ctime: this.now,
       nlink: 1,
       size,
-      mode: 33188,
+      mode: FILE_MODE,
       uid: this.uid,
       gid: this.gid
     };
   }
   /**
-   * Fold merged stat attributes into a FUSE attr. The workspace stat
+   * Fold merged stat attributes into an attr record. 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.
+   * visible through a mount. String uid/gid (names) are skipped: the kernel
+   * wants numeric ids and there is no user db to map against.
    */
   applyStatAttrs(entry, s) {
     if (s.mode !== null) {
@@ -460,67 +617,46 @@ var MirageFS = class {
     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;
+      const ms = mtimeMs(s);
+      if (ms !== null) {
+        entry.mtime = new Date(ms);
+        entry.ctime = new Date(ms);
       }
     }
     return entry;
   }
   /**
-   * The target to present for a namespace link at a FUSE path, or null
+   * The target to present for a namespace link at a mount 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;
+    const links = this.ops.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;
+    let virtualTarget = target;
     if (this.root !== "") {
       if (target === this.root) {
-        fuseTarget = "/";
+        virtualTarget = "/";
       } else if (target.startsWith(this.root + "/")) {
-        fuseTarget = target.slice(this.root.length);
+        virtualTarget = 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);
+    return posix2.relative(parent, virtualTarget);
   }
   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);
-      if (p.startsWith(normalized) || pBare === bare) return true;
-    }
-    return false;
-  }
-  virtualChildren(path4) {
-    const normalized = path4 === "/" ? "/" : rstripSlash(path4) + "/";
-    const children = /* @__PURE__ */ new Set();
-    for (const p of this.prefixes) {
-      if (p.startsWith(normalized) && p !== normalized) {
-        const rest = p.slice(normalized.length);
-        const child = rest.split("/")[0];
-        if (child !== void 0 && child !== "") children.add(child);
-      }
-    }
-    return [...children].sort();
-  }
   cachedSize(path4) {
     for (const ctx of this.handles.values()) {
       if (ctx.path === path4 && ctx.data !== void 0) return ctx.data.byteLength;
@@ -543,7 +679,7 @@ var MirageFS = class {
    * 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`).
+   * `prefetch_read`).
    */
   async prefetch(path4) {
     const cached = this.cachedData(path4);
@@ -552,7 +688,7 @@ var MirageFS = class {
     if (inflight !== void 0) return inflight;
     const promise = (async () => {
       try {
-        const data = await this.ws.fs.readFile(this.resolve(path4));
+        const data = await this.ops.readFile(this.resolve(path4));
         this.prefetchCache.set(path4, { data, expires: Date.now() + PREFETCH_TTL_MS });
         return data;
       } catch {
@@ -564,14 +700,215 @@ var MirageFS = class {
     this.prefetchInflight.set(path4, promise);
     return promise;
   }
-  /** Drain and return accumulated op records (mirrors Python's drain_ops). */
+  /** Drain and return accumulated op records (mirrors Python's drainOps). */
   drainOps() {
-    const records = [...this.ws.records];
-    this.ws.records.length = 0;
+    const records = [...this.ops.records];
+    this.ops.records.length = 0;
     return records;
   }
   async writeFile(path4, data) {
-    await this.ws.dispatch("write", this.resolve(path4), [data]);
+    await this.ops.writeFile(this.resolve(path4), data);
+  }
+  /**
+   * Merge buffered writes over the raw base and persist the result.
+   * The base is read raw so a flush never stores a rendered view back
+   * into the mount.
+   */
+  async applyWrites(path4, writes) {
+    let existing = new Uint8Array(0);
+    try {
+      existing = await this.ops.readFile(this.resolve(path4), { raw: true });
+    } catch {
+    }
+    await this.writeFile(path4, mergeWrites(existing, writes));
+  }
+  // ── POSIX surface (throws; adapters classify) ────────────────────
+  async getattr(path4) {
+    if (path4 === "/") return this.dirStat();
+    const name = path4.slice(path4.lastIndexOf("/") + 1);
+    if (isMacosMetadata(name)) {
+      throw errnoError("ENOENT", `no such file or directory: ${path4}`);
+    }
+    const target = this.linkTarget(path4);
+    if (target !== null) return this.linkStat(target);
+    const s = await this.ops.stat(this.resolve(path4));
+    if (s.type === FileType.DIRECTORY) {
+      return this.applyStatAttrs(this.dirStat(), s);
+    }
+    let size = s.size;
+    size ??= this.cachedSize(path4) ?? 0;
+    return this.applyStatAttrs(this.fileStat(size), s);
+  }
+  /** Attributes through an open handle, or path-based when not hydrated. */
+  async fgetattr(path4, fd) {
+    const ctx = this.handles.get(fd);
+    if (ctx?.data !== void 0) return this.fileStat(ctx.data.byteLength);
+    return this.getattr(path4);
+  }
+  async readdir(path4) {
+    const names = /* @__PURE__ */ new Set();
+    const entries = await this.ops.readdir(this.resolve(path4));
+    for (const e of entries) {
+      const part = rstripSlash2(e).split("/").pop() ?? "";
+      if (part !== "" && !isMacosMetadata(part)) names.add(part);
+    }
+    return [".", "..", ...[...names].sort(compareCodePoints)];
+  }
+  async read(path4, fd, pos, len) {
+    const ctx = this.handles.get(fd);
+    if (ctx !== void 0 && ctx.data === void 0) {
+      const cached = this.cachedData(path4);
+      ctx.data = cached ?? await this.ops.readFile(this.resolve(path4));
+    }
+    const data = ctx?.data ?? this.cachedData(path4) ?? await this.ops.readFile(this.resolve(path4));
+    return data.subarray(pos, pos + len);
+  }
+  /** Buffer a write on its handle, or apply it directly when there is none. */
+  async write(path4, fd, data, pos) {
+    const ctx = this.handles.get(fd);
+    if (ctx !== void 0) {
+      ctx.writeBuf ??= [];
+      ctx.writeBuf.push([pos, data]);
+      return;
+    }
+    await this.applyWrites(path4, [[pos, data]]);
+  }
+  async create(path4) {
+    try {
+      await this.ops.create(this.resolve(path4));
+    } catch (dispatchErr) {
+      if (!isMissingOp(dispatchErr, "create")) throw dispatchErr;
+      await this.writeFile(path4, new Uint8Array(0));
+    }
+    return this.handles.add({ path: path4 });
+  }
+  async mkdir(path4) {
+    await this.ops.mkdir(this.resolve(path4));
+  }
+  readlink(path4) {
+    const target = this.linkTarget(path4);
+    if (target === null) throw errnoError("EINVAL", `not a symbolic link: ${path4}`);
+    return 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.
+   */
+  async symlink(src, dest) {
+    if (this.ops.links === null) throw errnoError("EROFS", "workspace has no namespace links");
+    const stored = src.startsWith("/") ? this.resolve(src) : src;
+    await this.ops.symlink(this.resolve(dest), stored);
+  }
+  async unlink(path4) {
+    const links = this.ops.links;
+    if (links?.isLink(this.resolve(path4)) === true) {
+      await links.unlink(this.resolve(path4));
+      this.xattrs.delete(path4);
+      this.prefetchCache.delete(path4);
+      return;
+    }
+    await this.ops.unlink(this.resolve(path4));
+    this.xattrs.delete(path4);
+  }
+  async rename(src, dst) {
+    await this.ops.rename(this.resolve(src), this.resolve(dst));
+    const moved = this.xattrs.get(src);
+    if (moved !== void 0) {
+      this.xattrs.delete(src);
+      this.xattrs.set(dst, moved);
+    }
+  }
+  async rmdir(path4) {
+    try {
+      const entries = await this.ops.readdir(this.resolve(path4));
+      if (entries.length > 0) {
+        throw errnoError("ENOTEMPTY", `directory not empty: ${path4}`);
+      }
+    } catch (err) {
+      if (err.code === "ENOTEMPTY") throw err;
+    }
+    await this.ops.rmdir(this.resolve(path4));
+    this.xattrs.delete(path4);
+  }
+  async truncate(path4, size) {
+    try {
+      await this.ops.truncate(this.resolve(path4), size);
+    } catch (dispatchErr) {
+      if (!isMissingOp(dispatchErr, "truncate")) throw dispatchErr;
+      const data = await this.ops.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(path4, out);
+    }
+  }
+  statfs() {
+    return {
+      bsize: 4096,
+      frsize: 4096,
+      blocks: 1024 * 1024,
+      bfree: 1024 * 1024,
+      bavail: 1024 * 1024,
+      files: 1e6,
+      ffree: 1e6,
+      favail: 1e6,
+      namemax: 255
+    };
+  }
+  setxattr(path4, name, value) {
+    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));
+  }
+  getxattr(path4, name) {
+    return this.xattrs.get(path4)?.get(name);
+  }
+  listxattr(path4) {
+    const attrs = this.xattrs.get(path4);
+    return attrs ? [...attrs.keys()] : [];
+  }
+  removexattr(path4, name) {
+    this.xattrs.get(path4)?.delete(name);
+  }
+  async open(path4) {
+    const s = await this.ops.stat(this.resolve(path4));
+    const ctx = { path: path4 };
+    if (s.size === null && s.type !== FileType.DIRECTORY) {
+      const data = await this.prefetch(path4);
+      if (data !== null) ctx.data = data;
+    }
+    return this.handles.add(ctx);
+  }
+  async release(fd) {
+    const ctx = this.handles.get(fd);
+    if (ctx?.writeBuf !== void 0 && ctx.writeBuf.length > 0) {
+      await this.flush(ctx.path, fd);
+    }
+    this.handles.pop(fd);
+  }
+  async flush(path4, fd) {
+    const ctx = this.handles.get(fd);
+    if (ctx?.writeBuf === void 0 || ctx.writeBuf.length === 0) return;
+    const writes = ctx.writeBuf;
+    ctx.writeBuf = [];
+    await this.applyWrites(path4, writes);
+  }
+};
+
+// src/fuse/fs.ts
+var MirageFS = class {
+  core;
+  constructor(ops, options = {}) {
+    this.core = new MountCore(ops, options);
+  }
+  /** Drain and return accumulated op records (mirrors Python's drainOps). */
+  drainOps() {
+    return this.core.drainOps();
   }
   // ── FUSE op surface (mirrors mfusepy Operations) ─────────────────
   ops() {
@@ -603,7 +940,7 @@ var MirageFS = class {
       removexattr: this.removexattr.bind(this),
       statfs: this.statfs.bind(this)
     };
-    const session = this.session;
+    const session = this.core.session;
     if (session === null) return table;
     const bound = {};
     for (const [name, fn] of Object.entries(table)) {
@@ -617,392 +954,232 @@ var MirageFS = class {
     return bound;
   }
   getattr(path4, cb) {
-    void (async () => {
-      if (path4 === "/") {
-        cb(0, this.dirStat());
-        return;
-      }
-      const name = path4.slice(path4.lastIndexOf("/") + 1);
-      if (isMacosMetadata(name)) {
-        cb(ENOENT);
-        return;
-      }
-      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(path4));
-        if (s.type === FileType.DIRECTORY) {
-          cb(0, this.applyStatAttrs(this.dirStat(), s));
-          return;
-        }
-        let size = s.size;
-        size ??= this.cachedSize(path4) ?? 0;
-        cb(0, this.applyStatAttrs(this.fileStat(size), s));
-      } catch (err) {
+    void this.core.getattr(path4).then(
+      (attr) => {
+        cb(0, attr);
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   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(path4, cb);
+    void this.core.fgetattr(path4, fd).then(
+      (attr) => {
+        cb(0, attr);
+      },
+      (err) => {
+        cb(classifyError(err));
+      }
+    );
   }
   readdir(path4, cb) {
-    void (async () => {
-      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);
-        }
-      }
-      try {
-        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);
-        }
-      } catch {
-        if (names.size === 0) {
-          cb(ENOENT);
-          return;
-        }
+    void this.core.readdir(path4).then(
+      (names) => {
+        cb(0, names);
+      },
+      (err) => {
+        cb(classifyError(err));
       }
-      cb(0, [".", "..", ...[...names].sort()]);
-    })();
+    );
   }
   read(path4, fd, buf, len, pos, cb) {
-    void (async () => {
-      const ctx = this.handles.get(fd);
-      try {
-        if (ctx !== void 0 && ctx.data === void 0) {
-          const cached = this.cachedData(path4);
-          ctx.data = cached ?? await this.ws.fs.readFile(this.resolve(path4));
-        }
-        const data = ctx?.data ?? this.cachedData(path4) ?? await this.ws.fs.readFile(this.resolve(path4));
-        const slice = data.subarray(pos, pos + len);
+    void this.core.read(path4, fd, pos, len).then(
+      (slice) => {
         buf.set(slice, 0);
         cb(slice.byteLength);
-      } catch {
+      },
+      (err) => {
+        if (err.code === "EACCES") {
+          cb(classifyError(err));
+          return;
+        }
         cb(0);
       }
-    })();
+    );
   }
   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) {
-      ctx.writeBuf ??= [];
-      ctx.writeBuf.push([pos, data]);
-      cb(len);
-      return;
-    }
-    void (async () => {
-      try {
-        let existing = new Uint8Array(0);
-        try {
-          existing = await this.ws.fs.readFile(this.resolve(path4), { raw: true });
-        } catch {
-        }
-        let merged = existing;
-        if (pos > merged.byteLength) {
-          const padded = new Uint8Array(pos + data.byteLength);
-          padded.set(merged, 0);
-          padded.set(data, pos);
-          merged = padded;
-        } else {
-          const size = Math.max(merged.byteLength, pos + data.byteLength);
-          const out = new Uint8Array(size);
-          out.set(merged.subarray(0, pos), 0);
-          out.set(data, pos);
-          if (pos + data.byteLength < merged.byteLength) {
-            out.set(merged.subarray(pos + data.byteLength), pos + data.byteLength);
-          }
-          merged = out;
-        }
-        await this.writeFile(path4, merged);
+    void this.core.write(path4, fd, data, pos).then(
+      () => {
         cb(len);
-      } catch {
+      },
+      (err) => {
+        if (err.code === "EACCES") {
+          cb(classifyError(err));
+          return;
+        }
         cb(0);
       }
-    })();
+    );
   }
   create(path4, _mode, cb) {
-    void (async () => {
-      try {
-        try {
-          await this.ws.dispatch("create", this.resolve(path4));
-        } catch (dispatchErr) {
-          if (!isMissingOp(dispatchErr, "create")) throw dispatchErr;
-          await this.writeFile(path4, new Uint8Array(0));
-        }
-        const fh = this.nextFh++;
-        this.handles.set(fh, { path: path4 });
+    void this.core.create(path4).then(
+      (fh) => {
         cb(0, fh);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   mkdir(path4, _mode, cb) {
-    void (async () => {
-      try {
-        await this.ws.dispatch("mkdir", this.resolve(path4));
+    void this.core.mkdir(path4).then(
+      () => {
         cb(0);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   readlink(path4, cb) {
-    const target = this.linkTarget(path4);
-    if (target === null) {
-      cb(EINVAL);
-      return;
+    try {
+      cb(0, this.core.readlink(path4));
+    } catch (err) {
+      cb(classifyError(err));
     }
-    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);
+    void this.core.symlink(src, dest).then(
+      () => {
         cb(0);
-      } catch (err) {
+      },
+      (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);
+    void this.core.unlink(path4).then(
+      () => {
         cb(0);
-        return;
-      }
-      try {
-        await this.ws.dispatch("unlink", this.resolve(path4));
-        this.xattrs.delete(path4);
-        cb(0);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   rename(src, dst, cb) {
-    void (async () => {
-      try {
-        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);
-        }
+    void this.core.rename(src, dst).then(
+      () => {
         cb(0);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   rmdir(path4, cb) {
-    void (async () => {
-      try {
-        try {
-          const entries = await this.ws.fs.readdir(this.resolve(path4));
-          if (entries.length > 0) {
-            cb(ENOTEMPTY);
-            return;
-          }
-        } catch {
-        }
-        await this.ws.dispatch("rmdir", this.resolve(path4));
-        this.xattrs.delete(path4);
+    void this.core.rmdir(path4).then(
+      () => {
         cb(0);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   truncate(path4, size, cb) {
-    void (async () => {
-      try {
-        try {
-          await this.ws.dispatch("truncate", this.resolve(path4), [size]);
-        } catch (dispatchErr) {
-          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(path4, out);
-        }
+    void this.core.truncate(path4, size).then(
+      () => {
         cb(0);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   statfs(_path, cb) {
-    cb(0, {
-      bsize: 4096,
-      frsize: 4096,
-      blocks: 1024 * 1024,
-      bfree: 1024 * 1024,
-      bavail: 1024 * 1024,
-      files: 1e6,
-      ffree: 1e6,
-      favail: 1e6,
-      namemax: 255
-    });
+    cb(0, this.core.statfs());
   }
   // 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(path4, _mode, cb) {
-    this.getattrValidate(path4, cb);
+    this.validate(path4, cb);
   }
   chown(path4, _uid, _gid, cb) {
-    this.getattrValidate(path4, cb);
+    this.validate(path4, cb);
   }
   utimens(path4, _atime, _mtime, cb) {
-    this.getattrValidate(path4, cb);
+    this.validate(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.
+    this.validate(path4, cb);
+  }
   setxattr(path4, name, value, _position, _flags, cb) {
-    this.getattr(path4, (code) => {
+    this.validate(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));
+      this.core.setxattr(path4, name, value);
       cb(0);
     });
   }
   getxattr(path4, name, _position, cb) {
-    this.getattr(path4, (code) => {
+    this.validate(path4, (code) => {
       if (code !== 0) {
         cb(code);
         return;
       }
-      cb(0, this.xattrs.get(path4)?.get(name));
+      cb(0, this.core.getxattr(path4, name));
     });
   }
   listxattr(path4, cb) {
-    this.getattr(path4, (code) => {
+    this.validate(path4, (code) => {
       if (code !== 0) {
         cb(code);
         return;
       }
-      const attrs = this.xattrs.get(path4);
-      cb(0, attrs ? [...attrs.keys()] : []);
+      cb(0, this.core.listxattr(path4));
     });
   }
   removexattr(path4, name, cb) {
-    this.getattr(path4, (code) => {
+    this.validate(path4, (code) => {
       if (code !== 0) {
         cb(code);
         return;
       }
-      this.xattrs.get(path4)?.delete(name);
+      this.core.removexattr(path4, name);
       cb(0);
     });
   }
-  getattrValidate(path4, cb) {
+  validate(path4, cb) {
     this.getattr(path4, (code) => {
       cb(code);
     });
   }
   open(path4, _flags, cb) {
-    void (async () => {
-      try {
-        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(path4);
-          if (data !== null) ctx.data = data;
-        }
-        const fh = this.nextFh++;
-        this.handles.set(fh, ctx);
+    void this.core.open(path4).then(
+      (fh) => {
         cb(0, fh);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   release(_path, fd, cb) {
-    this.handles.delete(fd);
-    cb(0);
+    void this.core.release(fd).then(
+      () => {
+        cb(0);
+      },
+      (err) => {
+        cb(classifyError(err));
+      }
+    );
   }
   flush(path4, fd, cb) {
-    const ctx = this.handles.get(fd);
-    if (ctx?.writeBuf === void 0 || ctx.writeBuf.length === 0) {
-      cb(0);
-      return;
-    }
-    const writes = ctx.writeBuf;
-    ctx.writeBuf = [];
-    void (async () => {
-      try {
-        let existing = new Uint8Array(0);
-        try {
-          existing = await this.ws.fs.readFile(this.resolve(path4), { raw: true });
-        } catch {
-        }
-        let total = existing.byteLength;
-        for (const [off, chunk] of writes) {
-          total = Math.max(total, off + chunk.byteLength);
-        }
-        const merged = new Uint8Array(total);
-        merged.set(existing, 0);
-        for (const [off, chunk] of writes) {
-          merged.set(chunk, off);
-        }
-        await this.writeFile(path4, merged);
+    void this.core.flush(path4, fd).then(
+      () => {
         cb(0);
-      } catch (err) {
+      },
+      (err) => {
         cb(classifyError(err));
       }
-    })();
+    );
   }
   fsync(path4, _datasync, fd, cb) {
     this.flush(path4, fd, cb);
@@ -1010,19 +1187,24 @@ var MirageFS = class {
 };
 
 // src/fuse/mount.ts
-function appendDirectIO(fuse) {
+function appendMountOptions(fuse, extras) {
   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."
+      "@zkochan/fuse-native no longer exposes _fuseOptions(); extra mount options cannot be applied. Update appendMountOptions 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`;
+    const missing = extras.filter((opt) => !serialized.includes(opt));
+    if (missing.length === 0) return serialized;
+    if (serialized === "") return `-o${missing.join(",")}`;
+    return `${serialized},${missing.join(",")}`;
   };
 }
+function appendDirectIO(fuse) {
+  appendMountOptions(fuse, ["direct_io"]);
+}
 async function loadFuse() {
   const mod = await loadOptionalPeer(
     () => import("@zkochan/fuse-native"),
@@ -1049,17 +1231,27 @@ function forceUnmount(mountpoint) {
   }
 }
 async function mount(ws, options = {}) {
+  const backend = prepareBackend(
+    options.backend ?? MountBackend2.FUSE,
+    ws,
+    void 0,
+    options.rootPrefix ?? ""
+  );
   const Fuse = await loadFuse();
+  const isFskit = backend === MountBackend2.FSKIT;
   let mountpoint;
   let ownsMountpoint = false;
   if (options.mountpoint !== void 0) {
-    mkdirSync(options.mountpoint, { recursive: true });
+    checkMountpoint(backend, options.mountpoint);
+    if (!isFskit) mkdirSync(options.mountpoint, { recursive: true });
     mountpoint = options.mountpoint;
+  } else if (isFskit) {
+    mountpoint = `${FSKIT_MOUNT_ROOT}/mirage-${randomBytes(4).toString("hex")}`;
   } else {
     mountpoint = mkdtempSync(join(tmpdir(), "mirage-fuse-"));
     ownsMountpoint = true;
   }
-  const mfs = new MirageFS(ws, {
+  const mfs = new MirageFS(ws.fs, {
     ...options.rootPrefix !== void 0 ? { rootPrefix: options.rootPrefix } : {},
     ...options.session !== void 0 ? { session: options.session } : {}
   });
@@ -1072,19 +1264,23 @@ 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) => {
+  if (isFskit) {
+    appendMountOptions(fuse, ["backend=fskit", `volname=${basename(mountpoint)}`]);
+  } else if (fuseOpts.directIO !== false) {
+    appendDirectIO(fuse);
+  }
+  await new Promise((resolve2, reject) => {
     fuse.mount((err) => {
-      if (err === null) resolve();
+      if (err === null) resolve2();
       else reject(err);
     });
   });
   return {
     mountpoint,
     ownsMountpoint,
-    unmount: () => new Promise((resolve, reject) => {
+    unmount: () => new Promise((resolve2, reject) => {
       fuse.unmount((err) => {
-        if (err === null) resolve();
+        if (err === null) resolve2();
         else reject(err);
       });
     })
@@ -1202,17 +1398,89 @@ var Mount = class {
 import { createRequire } from "module";
 import { registerCompressionCodec } from "@struktoai/mirage-core";
 var requireCjs = createRequire(import.meta.url);
-var { Bzip2 } = requireCjs("compressjs");
+var bunzip = requireCjs("seek-bzip");
 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)))
+  decompress: (bytes) => Promise.resolve(Uint8Array.from(bunzip.decode(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/runtime/sandbox/daytona/runtime.ts
+import {
+  loadOptionalPeer as loadOptionalPeer2,
+  registerRuntime,
+  RemoteSandbox,
+  stdinPath,
+  stdinRedirect
+} from "@struktoai/mirage-core";
+
+// src/runtime/sandbox/daytona/config.ts
+var DAYTONA_CONFIG_KEYS = ["env", "sandboxId", "apiKey"];
+
+// src/runtime/sandbox/daytona/runtime.ts
+var ENC = new TextEncoder();
+var DaytonaRuntime = class extends RemoteSandbox {
+  name = "daytona";
+  client = null;
+  sandbox = null;
+  constructor(options = {}) {
+    super(options, DAYTONA_CONFIG_KEYS);
+    if (!this.config.sandboxId) {
+      throw new Error("daytona config needs sandboxId: the id of a live sandbox you created");
+    }
+  }
+  // The SDK loader as a seam: tests substitute a fake module here.
+  loadSdk() {
+    return loadOptionalPeer2(() => import("@daytonaio/sdk"), {
+      feature: "the 'daytona' runtime",
+      packageName: "@daytonaio/sdk"
+    });
+  }
+  async connect() {
+    if (this.client === null) {
+      const sdk = await this.loadSdk();
+      this.client = new sdk.Daytona(
+        this.config.apiKey !== void 0 ? { apiKey: this.config.apiKey } : void 0
+      );
+    }
+    this.sandbox = await this.client.get(this.config.sandboxId);
+  }
+  async execLine(line, stdin, env, cwd) {
+    if (this.sandbox === null) throw new Error("daytona sandbox not connected");
+    let command = line;
+    if (stdin !== null) {
+      const path4 = stdinPath();
+      await this.upload(path4, stdin);
+      command = stdinRedirect(line, path4);
+    }
+    const response = await this.sandbox.process.executeCommand(command, cwd, env);
+    return {
+      stdout: ENC.encode(response.result),
+      stderr: null,
+      exitCode: response.exitCode
+    };
+  }
+  async upload(path4, data) {
+    if (this.sandbox === null) throw new Error("daytona sandbox not connected");
+    const slash = path4.lastIndexOf("/");
+    const parent = slash > 0 ? path4.slice(0, slash) : "";
+    if (parent !== "") await this.sandbox.fs.createFolder(parent, "755");
+    await this.sandbox.fs.uploadFile(Buffer.from(data), path4);
+  }
+  /** Release the SDK client; the sandbox itself is the user's. */
+  async close() {
+    this.sandbox = null;
+    if (this.client !== null) {
+      await this.client[Symbol.asyncDispose]();
+      this.client = null;
+    }
+  }
+};
+registerRuntime("daytona", DaytonaRuntime);
+
 // src/workspace.ts
 var requireCjs2 = createRequire2(import.meta.url);
 var cachedParser = null;
@@ -1232,29 +1500,30 @@ var Workspace = class extends CoreWorkspace {
   fuseManagers = /* @__PURE__ */ new Map();
   constructor(resources, options = {}) {
     const specs = {};
-    const commandSafeguards = {
-      ...options.commandSafeguards ?? {}
+    const commandLimits = {
+      ...options.commandLimits ?? {}
     };
-    const fuseTargets = [];
+    const mountTargets = [];
     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]);
+        if (value.options.commandLimits !== void 0)
+          commandLimits[prefix] = value.options.commandLimits;
+        const backend = value.options.backend ?? MountBackend3.VFS;
+        if (KERNEL_BACKENDS2.includes(backend))
+          mountTargets.push([prefix, backend, value.options.mountpoint]);
       } else {
         specs[prefix] = value;
       }
     }
     super(specs, {
       ...options,
-      ...Object.keys(commandSafeguards).length > 0 ? { commandSafeguards } : {},
+      ...Object.keys(commandLimits).length > 0 ? { commandLimits } : {},
       shellParserFactory: options.shellParserFactory ?? loadShellParser
     });
-    if (fuseTargets.length > 0) {
-      const setups = fuseTargets.map(
-        ([prefix, target]) => this.addFuseMount(prefix, typeof target === "string" ? target : void 0).then(
+    if (mountTargets.length > 0) {
+      const setups = mountTargets.map(
+        ([prefix, backend, mountpoint]) => this.addFuseMount(prefix, mountpoint, void 0, backend).then(
           () => void 0,
           (err) => {
             process.stderr.write(
@@ -1288,7 +1557,7 @@ var Workspace = class extends CoreWorkspace {
    * 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) {
+  async addFuseMount(prefix, mountpoint, sessionId, backend) {
     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);
@@ -1298,7 +1567,8 @@ var Workspace = class extends CoreWorkspace {
       const mp = await fm.setup(this, {
         rootPrefix: prefix,
         ...mountpoint !== void 0 ? { mountpoint } : {},
-        ...session !== void 0 ? { session } : {}
+        ...session !== void 0 ? { session } : {},
+        ...backend !== void 0 ? { backend } : {}
       });
       if (mountpoint === void 0) this.registerFuseMount(key, mp);
       return mp;
@@ -1346,11 +1616,22 @@ var Workspace = class extends CoreWorkspace {
 };
 
 // src/observe/disk_store.ts
-import { appendFile, mkdir, readdir, readFile, rmdir, unlink, writeFile } from "fs/promises";
+import {
+  appendFile,
+  mkdir,
+  readdir,
+  readFile,
+  rmdir,
+  stat as stat2,
+  unlink,
+  writeFile
+} from "fs/promises";
 import path from "path";
-var DiskObserverStore = class {
+import { ObserverStoreBase } from "@struktoai/mirage-core";
+var DiskObserverStore = class extends ObserverStoreBase {
   root;
   constructor(root) {
+    super();
     this.root = root;
   }
   abs(key) {
@@ -1366,9 +1647,6 @@ var DiskObserverStore = class {
     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();
@@ -1384,22 +1662,23 @@ var DiskObserverStore = class {
     for (const absPath of files) await unlink(absPath);
     for (const d of [...dirs].reverse()) await rmdir(d);
   }
-  close() {
-    return Promise.resolve();
+  async rootIsDir() {
+    try {
+      return (await stat2(this.root)).isDirectory();
+    } catch (err) {
+      if (err.code === "ENOENT") return false;
+      throw err;
+    }
   }
   async walk() {
     const files = [];
     const dirs = [];
+    if (!await this.rootIsDir()) return { files, 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;
-      }
+      const entries = await readdir(d, { withFileTypes: true });
       dirs.push(d);
       for (const entry of entries) {
         const full = path.join(d, entry.name);
@@ -1412,12 +1691,14 @@ var DiskObserverStore = class {
 };
 
 // src/observe/redis_store.ts
-var RedisObserverStore = class {
+import { compareCodePoints as compareCodePoints2, ObserverStoreBase as ObserverStoreBase2 } from "@struktoai/mirage-core";
+var RedisObserverStore = class extends ObserverStoreBase2 {
   url;
   prefix;
   indexKey;
   clientPromise = null;
   constructor(options = {}) {
+    super();
     this.url = options.url ?? "redis://localhost:6379/0";
     this.prefix = options.keyPrefix ?? "mirage:observer:";
     this.indexKey = `${this.prefix}keys`;
@@ -1447,9 +1728,6 @@ var RedisObserverStore = class {
     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);
@@ -1457,7 +1735,7 @@ var RedisObserverStore = class {
   async indexedPaths() {
     const c = await this.client();
     const members = await c.sMembers(this.indexKey);
-    return [...members].sort();
+    return [...members].sort(compareCodePoints2);
   }
   async readPaths(paths) {
     const out = /* @__PURE__ */ new Map();
@@ -1488,13 +1766,144 @@ var RedisObserverStore = class {
   }
 };
 
+// src/shell/console/redis/store.ts
+import {
+  Channel
+} from "@struktoai/mirage-core";
+
+// src/shell/console/redis/constants.ts
+import { readFileSync as readFileSync2 } from "fs";
+var APPEND_LUA = readFileSync2(new URL("./append.lua", import.meta.url), "utf8");
+var POLL_MS = 100;
+
+// src/shell/console/redis/store.ts
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var RedisConsoleStore = class {
+  url;
+  keyPrefix;
+  streamKey;
+  counterKey;
+  endedKey;
+  ttlSeconds;
+  clientPromise = null;
+  isClosed = false;
+  constructor(options = {}) {
+    this.url = options.url ?? "redis://localhost:6379/0";
+    this.keyPrefix = options.keyPrefix ?? "mirage:console:";
+    this.streamKey = `${this.keyPrefix}stream`;
+    this.counterKey = `${this.keyPrefix}seq`;
+    this.endedKey = `${this.keyPrefix}ended`;
+    this.ttlSeconds = options.ttlSeconds ?? 0;
+  }
+  get closed() {
+    return this.isClosed;
+  }
+  async client() {
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("redis"),
+        { feature: "RedisConsoleStore", packageName: "redis" }
+      );
+      const c = mod.createClient({
+        url: this.url,
+        socket: { reconnectStrategy: false }
+      });
+      await c.connect();
+      return c;
+    })();
+    return this.clientPromise;
+  }
+  /**
+   * Append one chunk, atomically against the console's ending.
+   *
+   * A dropped append (the console already ended) reports the last real
+   * chunk's seq; `JobConsole.emit` ignores the return and the drop is
+   * exactly its documented after-the-ending semantics.
+   */
+  async append(channel, data) {
+    const c = await this.client();
+    const ts = Date.now() / 1e3;
+    const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    const count = await c.eval(APPEND_LUA, {
+      keys: [this.streamKey, this.counterKey, this.endedKey],
+      arguments: [
+        channel,
+        buf,
+        String(ts),
+        channel === Channel.CONTROL ? "1" : "0",
+        String(this.ttlSeconds)
+      ]
+    });
+    return { seq: count - 1, ts, channel, data };
+  }
+  async readFrom(seq, limit) {
+    const c = await this.client();
+    const mod = await import("redis");
+    const mapping = { [mod.RESP_TYPES.BLOB_STRING]: Buffer };
+    const typed = c;
+    const entries = await typed.withTypeMapping(mapping).xRange(
+      this.streamKey,
+      `${(seq + 1).toString()}-0`,
+      "+",
+      limit === void 0 ? void 0 : { COUNT: limit }
+    );
+    const chunks = entries.map((entry) => this.chunk(entry));
+    const first = chunks[0];
+    const last = chunks[chunks.length - 1];
+    if (first !== void 0 && last !== void 0) {
+      return [chunks, last.seq + 1, first.seq > seq];
+    }
+    const raw = await c.get(this.counterKey);
+    const total = raw === null ? 0 : Number(raw);
+    return [[], Math.min(seq, total), false];
+  }
+  async wait(seq) {
+    if (this.isClosed) return;
+    const c = await this.client();
+    while (!this.isClosed) {
+      let raw;
+      try {
+        raw = await c.get(this.counterKey);
+      } catch (err) {
+        if (this.isClosed) return;
+        throw err;
+      }
+      if (raw !== null && Number(raw) > seq) return;
+      await sleep(POLL_MS);
+    }
+  }
+  async close() {
+    this.isClosed = true;
+    if (this.clientPromise === null) return;
+    const pending = this.clientPromise;
+    this.clientPromise = null;
+    const c = await pending;
+    await c.quit();
+  }
+  /** Delete the console's keys (test and integ teardown only). */
+  async clear() {
+    const c = await this.client();
+    await c.del([this.streamKey, this.counterKey, this.endedKey]);
+  }
+  chunk(entry) {
+    return {
+      seq: Number(entry.id.toString().split("-")[0]) - 1,
+      ts: Number(entry.message.t?.toString() ?? "0"),
+      channel: entry.message.c?.toString() ?? "stdout",
+      data: new Uint8Array(entry.message.d ?? Buffer.alloc(0))
+    };
+  }
+};
+
 // 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";
+// src/workspace/record/disk.ts
+import { mkdir as mkdir2, open, readFile as readFile2, readdir as readdir2, rename, stat as stat3, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
-import { generationOf, SessionStore } from "@struktoai/mirage-core";
+import { generationOf } from "@struktoai/mirage-core";
 var LOCK_STALE_SECONDS = 10;
 var LOCK_RETRY_SLEEP_MS = 5;
 var LOCK_RETRY_LIMIT = 2e3;
@@ -1632,14 +2041,14 @@ var DiskRecordClient = class {
   // True when the lock is gone or was stale and removed; false when a
   // live writer still holds it.
   async reclaimStaleLock(lockPath) {
-    let mtimeMs;
+    let mtimeMs2;
     try {
-      mtimeMs = (await stat2(lockPath)).mtimeMs;
+      mtimeMs2 = (await stat3(lockPath)).mtimeMs;
     } catch (e) {
       if (isMissing(e)) return true;
       throw e;
     }
-    const age = (Date.now() - mtimeMs) / 1e3;
+    const age = (Date.now() - mtimeMs2) / 1e3;
     if (age <= LOCK_STALE_SECONDS) return false;
     console.warn(`mirage: reclaiming stale lock ${lockPath} (age ${age.toFixed(1)}s)`);
     try {
@@ -1664,36 +2073,6 @@ var DiskRecordClient = class {
     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";
@@ -1852,10 +2231,43 @@ var RedisNamespaceStore = class extends NamespaceStore2 {
   }
 };
 
+// src/workspace/session/disk.ts
+import { SessionStore } from "@struktoai/mirage-core";
+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/session/redis.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { SessionStore as SessionStore2 } from "@struktoai/mirage-core";
-var CAS_SCRIPT = readFileSync2(new URL("./cas.lua", import.meta.url), "utf8");
+var CAS_SCRIPT = readFileSync3(new URL("./cas.lua", import.meta.url), "utf8");
 var RedisSessionStore = class extends SessionStore2 {
   url;
   key;
@@ -2118,14 +2530,10 @@ var fs = requireCjs3("node:fs");
 var fsMonkey = requireCjs3("fs-monkey");
 var { patchFs } = fsMonkey;
 function mountedPath(ws, p) {
-  try {
-    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;
-  }
+  const m = ws.registry.tryMountFor(p);
+  if (m === null) return false;
+  if (ws.syntheticRoot && m === ws.registry.rootMount) return false;
+  return true;
 }
 async function mirageStat(ws, p) {
   const s = await ws.fs.stat(p);
@@ -2336,8 +2744,11 @@ function metadataProvision(_accessor, paths, _texts, _opts) {
 
 // src/cache/redis/file.ts
 import {
+  CacheType,
   defaultFingerprint,
+  globEscape,
   parseLimit,
+  registerFileCacheStore,
   validateMaxDrainBytes
 } from "@struktoai/mirage-core";
 var RedisFileCacheStore = class extends RedisResource {
@@ -2426,6 +2837,23 @@ var RedisFileCacheStore = class extends RedisResource {
     if (fp === null) return false;
     return fp === remoteFingerprint;
   }
+  async evictPrefix(prefix) {
+    for (const key of [...this.drainTasks.keys()]) {
+      if (key.startsWith(prefix)) this.drainTasks.delete(key);
+    }
+    const escaped = globEscape(prefix);
+    const c = await this.cacheClient();
+    for (const base of [this.dataPrefix, this.metaPrefix]) {
+      const batch = [];
+      for await (const k of c.scanIterator({ MATCH: `${base}${escaped}*` })) {
+        if (Array.isArray(k)) batch.push(...k);
+        else batch.push(k);
+      }
+      if (batch.length > 0) await c.del(batch);
+    }
+  }
+  evictPaths(_paths) {
+  }
   async clear() {
     this.drainTasks.clear();
     const c = await this.cacheClient();
@@ -2450,387 +2878,1458 @@ var RedisFileCacheStore = class extends RedisResource {
     return out;
   }
 };
+registerFileCacheStore(CacheType.REDIS, (config) => {
+  return new RedisFileCacheStore({
+    ...config.limit !== void 0 ? { cacheLimit: config.limit } : {},
+    ...config.maxDrainBytes !== void 0 ? { maxDrainBytes: config.maxDrainBytes } : {},
+    ...config.url !== void 0 ? { url: config.url } : {},
+    ...config.keyPrefix !== void 0 ? { keyPrefix: config.keyPrefix } : {}
+  });
+});
 
 // src/resource/hf_models/config.ts
 var normalizeHfModelsConfig = normalizeHfRepoConfig;
 var redactHfModelsConfig = redactHfRepoConfig;
 
-// src/resource/lancedb/lancedb.ts
-import {
-  BaseResource,
-  LANCEDB_COMMANDS,
-  LANCEDB_OPS,
-  LANCEDB_PROMPT,
-  LanceDBAccessor,
-  lanceRead,
-  lanceReaddir,
-  lanceStat,
-  ResourceName,
-  resolveLanceDBConfig
+// src/index.ts
+import {
+  normalizeSlackConfig,
+  redactSlackConfig
+} from "@struktoai/mirage-core";
+import {
+  normalizeDiscordConfig,
+  redactDiscordConfig
+} from "@struktoai/mirage-core";
+import {
+  normalizeLinearConfig,
+  redactLinearConfig
+} from "@struktoai/mirage-core";
+import {
+  normalizeNotionConfig,
+  redactNotionConfig
+} from "@struktoai/mirage-core";
+import {
+  Mem0Resource,
+  OneDriveResource,
+  SharePointResource
+} from "@struktoai/mirage-core";
+
+// src/commands/cli/builtin/himalaya/index.ts
+import { CLISpec, Operand, Option, registerCliSpec } from "@struktoai/mirage-core";
+
+// src/commands/cli/builtin/himalaya/compose.ts
+import { FlagView } from "@struktoai/mirage-core";
+
+// src/commands/cli/builtin/himalaya/util.ts
+import {
+  mimeTypeFor,
+  IOResult,
+  PathSpec,
+  isMissingPath
+} from "@struktoai/mirage-core";
+
+// src/commands/cli/builtin/himalaya/builder.ts
+import { createHash } from "crypto";
+import {
+  assertHeaderValue,
+  encodeBase64Lines,
+  encodeMimeText as encodeText,
+  foldAddressList,
+  foldContentDisposition,
+  foldUnstructured,
+  materialize
 } from "@struktoai/mirage-core";
+var PREFIXES = { reply: "Re: ", forward: "Fwd: " };
+var ENC2 = new TextEncoder();
+function mixedBoundary(body, attachments) {
+  const digest = createHash("sha256").update(Buffer.from(body, "utf8"));
+  for (const attachment of attachments) {
+    digest.update(Buffer.from(attachment.filename, "utf8"));
+    digest.update(Buffer.from(attachment.contentType, "utf8"));
+    digest.update(attachment.data);
+  }
+  return digest.digest("hex").slice(0, 32);
+}
+function splitAddresses(values) {
+  return values.flatMap(
+    (value) => value.split(",").map((part) => part.trim()).filter((part) => part !== "")
+  );
+}
+function formatAddress(entry) {
+  const email = entry.email.trim();
+  const name = entry.name.trim();
+  return name !== "" && email !== "" ? `${name} <${email}>` : email;
+}
+function hasPrefix(subject, prefix) {
+  const head = subject.trimStart();
+  const marker = prefix.trim();
+  return head.slice(0, marker.length).toLowerCase() === marker.toLowerCase();
+}
+function replyRecipients(message) {
+  if (message.reply_to.length > 0) return message.reply_to.map((entry) => formatAddress(entry));
+  const rendered = formatAddress(message.from);
+  return rendered === "" ? [] : [rendered];
+}
+function quoteText(sourceText, headline) {
+  const trimmed = sourceText.trim();
+  if (trimmed === "") return "";
+  const lines = [];
+  if (headline.trim() !== "") lines.push(headline.replace(/\n+$/, ""));
+  for (const line of trimmed.split("\n")) {
+    lines.push(line.startsWith(">") ? `>${line}` : `> ${line}`);
+  }
+  return lines.join("\n");
+}
+function composeBody(userBody, quote2, signature, style) {
+  let body = userBody.replace(/\n+$/, "");
+  if (quote2 !== "") {
+    if (body === "") body = quote2;
+    else if (style === "bottom") body = `${quote2}
+
+${body}`;
+    else body = `${body}
+
+${quote2}`;
+  }
+  if (signature.trim() !== "") body = `${body}
+
+-- 
+${signature.replace(/\n+$/, "")}`;
+  return body;
+}
+function build(compose2, source = null) {
+  let recipients = [...compose2.to];
+  let subject = compose2.subject;
+  let sourceText = "";
+  const headLines = [foldAddressList("From", [compose2.sender])];
+  if (source !== null) {
+    const original = source.message;
+    const prefix = PREFIXES[source.mode];
+    subject ??= hasPrefix(original.subject, prefix) ? original.subject : `${prefix}${original.subject}`;
+    if (source.mode === "reply" && recipients.length === 0) {
+      recipients = replyRecipients(original);
+    }
+    if (original.message_id !== "") {
+      if (source.mode === "reply") {
+        headLines.push(foldUnstructured("In-Reply-To", original.message_id));
+      }
+      headLines.push(
+        foldUnstructured("References", [...original.references, original.message_id].join(" "))
+      );
+    }
+    sourceText = original.body_text;
+  }
+  if (recipients.length === 0) throw new Error("no recipient: pass --to");
+  for (const value of [
+    compose2.sender,
+    ...recipients,
+    ...compose2.cc,
+    ...compose2.bcc,
+    subject ?? ""
+  ]) {
+    assertHeaderValue(value);
+  }
+  headLines.push(foldAddressList("To", recipients));
+  if (compose2.cc.length > 0) headLines.push(foldAddressList("Cc", compose2.cc));
+  if (compose2.bcc.length > 0) headLines.push(foldAddressList("Bcc", compose2.bcc));
+  headLines.push(foldUnstructured("Subject", subject ?? ""));
+  const style = source !== null ? source.postingStyle : "top";
+  const headline = source !== null ? source.quoteHeadline : "";
+  const body = composeBody(
+    compose2.body,
+    quoteText(sourceText, headline),
+    compose2.signature ?? "",
+    style
+  );
+  const { cte, payload } = encodeText(body);
+  const rendered = payload.replaceAll("\n", "\r\n");
+  const attachments = compose2.attachments ?? [];
+  if (attachments.length === 0) {
+    headLines.push('Content-Type: text/plain; charset="utf-8"');
+    headLines.push(`Content-Transfer-Encoding: ${cte}`);
+    headLines.push("MIME-Version: 1.0");
+    return ENC2.encode(`${headLines.join("\r\n")}\r
+\r
+${rendered}`);
+  }
+  const boundary = mixedBoundary(body, attachments);
+  headLines.push("MIME-Version: 1.0");
+  headLines.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
+  const parts = [
+    `Content-Type: text/plain; charset="utf-8"\r
+Content-Transfer-Encoding: ${cte}\r
+\r
+${rendered}`
+  ];
+  for (const attachment of attachments) {
+    const attachmentHead = `Content-Type: ${attachment.contentType}\r
+Content-Transfer-Encoding: base64\r
+${foldContentDisposition(attachment.filename)}\r
+MIME-Version: 1.0`;
+    const encoded = encodeBase64Lines(attachment.data).replaceAll("\n", "\r\n");
+    parts.push(`${attachmentHead}\r
+\r
+${encoded}`);
+  }
+  const head = headLines.join("\r\n");
+  const joined = parts.join(`\r
+--${boundary}\r
+`);
+  return ENC2.encode(`${head}\r
+\r
+--${boundary}\r
+${joined}\r
+--${boundary}--\r
+`);
+}
+async function readBody(fl, stdin) {
+  const inline = fl.asStr("body");
+  if (inline !== void 0) return inline;
+  if (stdin === null) return "";
+  return new TextDecoder().decode(await materialize(stdin));
+}
 
-// src/resource/lancedb/store.ts
+// src/commands/cli/builtin/himalaya/smtp.ts
+import { loadOptionalPeer as loadOptionalPeer3 } from "@struktoai/mirage-core";
+var transporterCache = /* @__PURE__ */ new WeakMap();
+async function getTransporter(config) {
+  const existing = transporterCache.get(config);
+  if (existing !== void 0) return existing;
+  const mod = await loadOptionalPeer3(
+    () => import("nodemailer"),
+    { feature: "himalaya message send", packageName: "nodemailer" }
+  );
+  const transporter = mod.createTransport({
+    host: config.smtpHost,
+    port: config.smtpPort,
+    secure: config.smtpPort === 465,
+    auth: { user: config.username, pass: config.password }
+  });
+  transporterCache.set(config, transporter);
+  return transporter;
+}
+async function sendRaw(config, raw) {
+  const transporter = await getTransporter(config);
+  const parsed = await parseRfc822(raw);
+  const recipients = [
+    ...parsed.to.map((entry) => entry.email),
+    ...parsed.cc.map((entry) => entry.email),
+    ...bccAddresses(raw)
+  ].filter((email) => email !== "");
+  await transporter.sendMail({
+    raw: Buffer.from(stripBcc(raw)),
+    envelope: { from: parsed.from.email || config.username, to: recipients }
+  });
+  return parsed;
+}
+function bccAddresses(raw) {
+  const addresses = [];
+  for (const line of bccLines(raw)) {
+    const value = line.replace(/^bcc:/i, "");
+    for (const part of value.split(",")) {
+      const angled = /<([^>]+)>/.exec(part);
+      const email = (angled === null ? part : angled[1] ?? "").trim();
+      if (email !== "") addresses.push(email);
+    }
+  }
+  return addresses;
+}
+function bccLines(raw) {
+  const text = new TextDecoder().decode(raw);
+  const split = text.search(/\r?\n\r?\n/);
+  const head = split === -1 ? text : text.slice(0, split);
+  const found = [];
+  let collecting = false;
+  for (const line of head.split(/\r?\n/)) {
+    if (/^[ \t]/.test(line)) {
+      if (collecting) {
+        const last = found.pop() ?? "";
+        found.push(`${last} ${line.trim()}`);
+      }
+      continue;
+    }
+    collecting = /^bcc:/i.test(line);
+    if (collecting) found.push(line);
+  }
+  return found;
+}
+function stripBcc(raw) {
+  const text = new TextDecoder().decode(raw);
+  const split = text.search(/\r?\n\r?\n/);
+  if (split === -1) return raw;
+  const head = text.slice(0, split);
+  const rest = text.slice(split);
+  const kept = [];
+  let dropping = false;
+  for (const line of head.split(/\r?\n/)) {
+    if (/^[ \t]/.test(line)) {
+      if (!dropping) kept.push(line);
+      continue;
+    }
+    dropping = /^bcc:/i.test(line);
+    if (!dropping) kept.push(line);
+  }
+  return new TextEncoder().encode(kept.join("\r\n") + rest);
+}
+
+// src/commands/cli/builtin/himalaya/deliver.ts
+var SENT_ATTRIBUTE = "\\sent";
+var DEFAULT_SENT_FOLDER = "Sent";
+var SEEN_FLAG = "\\Seen";
+async function resolveSentFolder(accessor, configured) {
+  if (configured !== null && configured !== "") return configured;
+  const entries = await listFolderEntries(accessor);
+  const tagged = entries.find((entry) => entry.specialUse?.toLowerCase() === SENT_ATTRIBUTE);
+  return tagged?.name ?? DEFAULT_SENT_FOLDER;
+}
+async function saveSentCopy(config, raw, named = null) {
+  const accessor = new EmailAccessor(config);
+  try {
+    const folder = named ?? await resolveSentFolder(accessor, config.sentFolder);
+    const imap = await accessor.getImap();
+    const result = await imap.append(folder, Buffer.from(raw), [SEEN_FLAG]);
+    if (result === false) throw new Error(`${folder}: the server refused the message`);
+    return folder;
+  } finally {
+    await accessor.close();
+  }
+}
+async function deliver(config, raw, save = null) {
+  const parsed = await sendRaw(config, raw);
+  if (save === null && !config.saveCopy) return { parsed, warning: "" };
+  try {
+    await saveSentCopy(config, raw, save);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return { parsed, warning: `himalaya: sent copy not saved: ${reason}
+` };
+  }
+  return { parsed, warning: "" };
+}
+
+// src/commands/cli/builtin/himalaya/util.ts
+var ENC3 = new TextEncoder();
+function addressList(addresses) {
+  return addresses.map((entry) => entry.name === "" ? entry.email : `${entry.name} <${entry.email}>`).join(", ");
+}
+function firstText(texts, label) {
+  const value = texts[0];
+  if (value === void 0) throw new Error(`${label} is required`);
+  return value;
+}
+async function loadAttachments(doors, paths) {
+  if (paths.length === 0) return [];
+  const dispatch = doors?.dispatch;
+  if (dispatch === void 0) {
+    throw new Error("--attach needs a workspace to read files from");
+  }
+  const attachments = [];
+  for (const path4 of paths) {
+    let data;
+    try {
+      ;
+      [data] = await dispatch("read", PathSpec.fromStrPath(path4));
+    } catch (err) {
+      if (isMissingPath(err)) {
+        throw new Error(`read attachment ${path4}: No such file or directory`);
+      }
+      throw err;
+    }
+    const trimmed = path4.replace(/\/+$/, "");
+    const filename = trimmed.slice(trimmed.lastIndexOf("/") + 1) || "attachment";
+    attachments.push({
+      filename,
+      contentType: mimeTypeFor(filename),
+      data: data instanceof Uint8Array ? data : new Uint8Array(data)
+    });
+  }
+  return attachments;
+}
+async function route(config, fl, stdin, source, doors) {
+  const raw = build(
+    {
+      sender: fl.asStr("from") ?? config.username,
+      to: splitAddresses(fl.asList("to")),
+      cc: splitAddresses(fl.asList("cc")),
+      bcc: splitAddresses(fl.asList("bcc")),
+      subject: fl.asStr("subject") ?? null,
+      body: await readBody(fl, stdin),
+      signature: fl.asStr("signature") ?? null,
+      attachments: await loadAttachments(doors, fl.asList("attach"))
+    },
+    source
+  );
+  const save = fl.asStr("save") ?? null;
+  if (!fl.asBool("send")) {
+    if (save === null) return [raw, new IOResult()];
+    const folder = await saveSentCopy(config, raw, save);
+    const filed = await parseRfc822(raw);
+    const saved = {
+      status: "saved",
+      mailbox: folder,
+      to: addressList(filed.to),
+      subject: filed.subject
+    };
+    return [ENC3.encode(JSON.stringify(saved)), new IOResult()];
+  }
+  const { parsed, warning } = await deliver(config, raw, save);
+  const result = {
+    status: "sent",
+    to: addressList(parsed.to),
+    subject: parsed.subject
+  };
+  return [
+    ENC3.encode(JSON.stringify(result)),
+    new IOResult({ stderr: warning === "" ? null : ENC3.encode(warning) })
+  ];
+}
+
+// src/commands/cli/builtin/himalaya/compose.ts
+async function compose(inv) {
+  return route(inv.config, new FlagView(inv.flags), inv.stdin, null, inv.doors);
+}
+
+// src/commands/cli/builtin/himalaya/forward.ts
+import { FlagView as FlagView2 } from "@struktoai/mirage-core";
+async function forward(inv) {
+  const fl = new FlagView2(inv.flags);
+  const uid = firstText(inv.texts, "message id");
+  const mailbox = fl.asStr("mailbox") ?? "INBOX";
+  const accessor = new EmailAccessor(inv.config);
+  let original;
+  try {
+    original = await fetchMessage(accessor, mailbox, uid);
+  } finally {
+    await accessor.close();
+  }
+  return route(
+    inv.config,
+    fl,
+    inv.stdin,
+    {
+      message: original,
+      mode: "forward",
+      postingStyle: fl.asStr("posting_style") === "bottom" ? "bottom" : "top",
+      quoteHeadline: fl.asStr("quote_headline") ?? ""
+    },
+    inv.doors
+  );
+}
+
+// src/commands/cli/builtin/himalaya/list.ts
 import {
-  loadOptionalPeer as loadOptionalPeer2
+  FlagView as FlagView3,
+  IOResult as IOResult2
 } from "@struktoai/mirage-core";
-function toStr(value) {
-  if (value === null || value === void 0) return "";
-  if (typeof value === "object") return JSON.stringify(value);
-  return String(value);
-}
-function eqClause(column, value) {
-  if (/^-?\d+$/.test(value)) return `${column} = ${value}`;
-  return `${column} = '${value.replace(/'/g, "''")}'`;
-}
-function whereClause(filters) {
-  return Object.entries(filters).map(([col, val]) => eqClause(col, val)).join(" AND ");
-}
-var LanceDBStore = class {
-  config;
-  db = null;
-  tables = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-  }
-  async connection() {
-    if (this.db === null) {
-      const options = {};
-      if (this.config.apiKey !== null) options.apiKey = this.config.apiKey;
-      if (this.config.storageOptions !== null) options.storageOptions = this.config.storageOptions;
-      if (this.config.uri.startsWith("db://")) {
-        options.region = this.config.region;
-        if (this.config.hostOverride !== null) options.hostOverride = this.config.hostOverride;
+
+// src/commands/cli/builtin/himalaya/query.ts
+import { compareCodePoints as compareCodePoints3 } from "@struktoai/mirage-core";
+var CONDITIONS = ["date", "before", "after", "from", "to", "subject", "body", "flag"];
+var SORT_KINDS = ["date", "from", "to", "subject"];
+var FLAGS = {
+  seen: "SEEN",
+  answered: "ANSWERED",
+  flagged: "FLAGGED",
+  draft: "DRAFT",
+  deleted: "DELETED"
+};
+var IMAP_MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var QueryError = class extends Error {
+};
+function tokenize(source) {
+  const tokens = [];
+  let index = 0;
+  while (index < source.length) {
+    const char = source.charAt(index);
+    if (/\s/.test(char)) {
+      index += 1;
+      continue;
+    }
+    if (char === "(" || char === ")") {
+      tokens.push({ text: char, quoted: false });
+      index += 1;
+      continue;
+    }
+    if (char === '"') {
+      index += 1;
+      const chars = [];
+      while (index < source.length && source.charAt(index) !== '"') {
+        if (source.charAt(index) === "\\" && index + 1 < source.length) index += 1;
+        chars.push(source.charAt(index));
+        index += 1;
+      }
+      if (index >= source.length) throw new QueryError("unterminated quoted pattern");
+      index += 1;
+      tokens.push({ text: chars.join(""), quoted: true });
+      continue;
+    }
+    const start = index;
+    while (index < source.length && !/[\s()]/.test(source.charAt(index))) index += 1;
+    tokens.push({ text: source.slice(start, index), quoted: false });
+  }
+  return tokens;
+}
+function keyword(token) {
+  if (token === void 0 || token.quoted) return null;
+  return token.text.toLowerCase();
+}
+function quote(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function imapDate(text) {
+  const parts = text.split("-");
+  if (parts.length !== 3) {
+    throw new QueryError(`invalid date '${text}', expected yyyy-mm-dd`);
+  }
+  const year = Number(parts[0]);
+  const month = Number(parts[1]);
+  const day = Number(parts[2]);
+  const value = new Date(Date.UTC(year, month - 1, day));
+  if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day) || Number.isNaN(value.getTime()) || value.getUTCMonth() !== month - 1 || value.getUTCDate() !== day) {
+    throw new QueryError(`invalid date '${text}'`);
+  }
+  return value;
+}
+function formatDate(value) {
+  const day = String(value.getUTCDate()).padStart(2, "0");
+  const month = IMAP_MONTHS[value.getUTCMonth()] ?? "Jan";
+  return `${day}-${month}-${String(value.getUTCFullYear())}`;
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  index = 0;
+  peek() {
+    return this.tokens[this.index];
+  }
+  take() {
+    const token = this.peek();
+    if (token === void 0) throw new QueryError("unexpected end of query");
+    this.index += 1;
+    return token;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (keyword(this.peek()) === "or") {
+      this.take();
+      left = `OR ${left} ${this.parseAnd()}`;
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseUnary();
+    while (keyword(this.peek()) === "and") {
+      this.take();
+      left = `(${left} ${this.parseUnary()})`;
+    }
+    return left;
+  }
+  parseUnary() {
+    const word = keyword(this.peek());
+    if (word === "not") {
+      this.take();
+      return `NOT ${this.parseUnary()}`;
+    }
+    if (word === "(") {
+      this.take();
+      const inner = this.parseOr();
+      if (keyword(this.peek()) !== ")") throw new QueryError("missing closing ')'");
+      this.take();
+      return inner;
+    }
+    return this.parseCondition();
+  }
+  parseCondition() {
+    const token = this.take();
+    const word = keyword(token);
+    if (word === null || !CONDITIONS.includes(word)) {
+      throw new QueryError(
+        `expected a condition (${CONDITIONS.join(", ")}) but found '${token.text}'`
+      );
+    }
+    const value = this.take().text;
+    if (word === "date") return `SENTON ${formatDate(imapDate(value))}`;
+    if (word === "before") return `SENTBEFORE ${formatDate(imapDate(value))}`;
+    if (word === "after") {
+      const next = new Date(imapDate(value).getTime() + 864e5);
+      return `SENTSINCE ${formatDate(next)}`;
+    }
+    if (word === "flag") {
+      const key = FLAGS[value.toLowerCase()];
+      if (key === void 0) {
+        throw new QueryError(
+          `unknown flag '${value}', expected one of ${Object.keys(FLAGS).sort(compareCodePoints3).join(", ")}`
+        );
+      }
+      return key;
+    }
+    return `${word.toUpperCase()} ${quote(value)}`;
+  }
+  parseSorters() {
+    this.take();
+    if (keyword(this.peek()) !== "by") throw new QueryError("expected 'by' after 'order'");
+    this.take();
+    const sorters = [];
+    for (; ; ) {
+      const kind = keyword(this.peek());
+      if (kind === null || !SORT_KINDS.includes(kind)) break;
+      this.take();
+      let descending = false;
+      const order = keyword(this.peek());
+      if (order === "asc" || order === "desc") {
+        this.take();
+        descending = order === "desc";
       }
-      const { connect } = await loadOptionalPeer2(() => import("@lancedb/lancedb"), {
-        feature: "LanceDBResource",
-        packageName: "@lancedb/lancedb"
+      sorters.push({ kind, descending });
+    }
+    if (sorters.length === 0) {
+      throw new QueryError(`expected a sort key (${SORT_KINDS.join(", ")}) after 'order by'`);
+    }
+    return sorters;
+  }
+};
+function parseQuery(source) {
+  const parser = new Parser(tokenize(source));
+  let criteria = "ALL";
+  const head = keyword(parser.peek());
+  if (head !== null && head !== "order") criteria = parser.parseOr();
+  let sorters = [];
+  if (keyword(parser.peek()) === "order") sorters = parser.parseSorters();
+  const leftover = parser.peek();
+  if (leftover !== void 0) {
+    throw new QueryError(`unexpected '${leftover.text}' at end of query`);
+  }
+  return { criteria, sorters };
+}
+function sentAt(header) {
+  const value = Date.parse(header.date);
+  return Number.isNaN(value) ? 0 : value;
+}
+var SORT_KEYS = {
+  date: sentAt,
+  from: (header) => header.from.email,
+  to: (header) => header.to[0]?.email ?? "",
+  subject: (header) => header.subject
+};
+function compare(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  return String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
+}
+function sortHeaders(headers, sorters) {
+  const ordered = [...headers];
+  if (sorters.length === 0) {
+    ordered.sort((a, b) => sentAt(b) - sentAt(a));
+    return ordered;
+  }
+  for (const sorter of [...sorters].reverse()) {
+    const key = SORT_KEYS[sorter.kind];
+    ordered.sort((a, b) => sorter.descending ? compare(key(b), key(a)) : compare(key(a), key(b)));
+  }
+  return ordered;
+}
+function uidBudget(page, pageSize, sorters, maxMessages) {
+  if (sorters.length > 0) return maxMessages;
+  return Math.min(Math.max(page, 1) * pageSize, maxMessages);
+}
+function pageSlice(items, page, pageSize) {
+  const start = Math.max(page - 1, 0) * pageSize;
+  return items.slice(start, start + pageSize);
+}
+
+// src/commands/cli/builtin/himalaya/list.ts
+var DEFAULT_PAGE_SIZE = 25;
+async function listEnvelopes(inv) {
+  const fl = new FlagView3(inv.flags);
+  const mailbox = fl.asStr("mailbox") ?? "INBOX";
+  const page = fl.asInt("page") ?? 1;
+  const pageSize = fl.asInt("page_size") ?? DEFAULT_PAGE_SIZE;
+  const account = inv.config;
+  const budget = uidBudget(page, pageSize, [], account.maxMessages);
+  const accessor = new EmailAccessor(account);
+  let headers;
+  try {
+    const uids = await listMessageUids(accessor, mailbox, "ALL", budget);
+    headers = uids.length > 0 ? await fetchHeaders(accessor, mailbox, uids) : [];
+  } finally {
+    await accessor.close();
+  }
+  const pageOf = pageSlice(sortHeaders(headers, []), page, pageSize);
+  const out = messagesJsonBytes(pageOf);
+  return [out, new IOResult2()];
+}
+
+// src/commands/cli/builtin/himalaya/read.ts
+import {
+  FlagView as FlagView4,
+  IOResult as IOResult3
+} from "@struktoai/mirage-core";
+async function read(inv) {
+  const fl = new FlagView4(inv.flags);
+  const uid = firstText(inv.texts, "message id");
+  const mailbox = fl.asStr("mailbox") ?? "INBOX";
+  const accessor = new EmailAccessor(inv.config);
+  try {
+    if (fl.asBool("raw")) {
+      const raw = await fetchRawMessage(accessor, mailbox, uid);
+      return [raw, new IOResult3()];
+    }
+    const processed = await fetchMessage(accessor, mailbox, uid);
+    const out = messageJsonBytes(processed);
+    return [out, new IOResult3()];
+  } finally {
+    await accessor.close();
+  }
+}
+
+// src/commands/cli/builtin/himalaya/reply.ts
+import { FlagView as FlagView5 } from "@struktoai/mirage-core";
+async function reply(inv) {
+  const fl = new FlagView5(inv.flags);
+  const uid = firstText(inv.texts, "message id");
+  const mailbox = fl.asStr("mailbox") ?? "INBOX";
+  const accessor = new EmailAccessor(inv.config);
+  let original;
+  try {
+    original = await fetchMessage(accessor, mailbox, uid);
+  } finally {
+    await accessor.close();
+  }
+  return route(
+    inv.config,
+    fl,
+    inv.stdin,
+    {
+      message: original,
+      mode: "reply",
+      postingStyle: fl.asStr("posting_style") === "bottom" ? "bottom" : "top",
+      quoteHeadline: fl.asStr("quote_headline") ?? ""
+    },
+    inv.doors
+  );
+}
+
+// src/commands/cli/builtin/himalaya/search.ts
+import {
+  FlagView as FlagView6,
+  IOResult as IOResult4
+} from "@struktoai/mirage-core";
+async function searchEnvelopes(inv) {
+  const fl = new FlagView6(inv.flags);
+  const mailbox = fl.asStr("mailbox") ?? "INBOX";
+  const page = fl.asInt("page") ?? 1;
+  const pageSize = fl.asInt("page_size") ?? DEFAULT_PAGE_SIZE;
+  const query = parseQuery(inv.texts.join(" "));
+  const account = inv.config;
+  const budget = uidBudget(page, pageSize, query.sorters, account.maxMessages);
+  const accessor = new EmailAccessor(account);
+  let headers;
+  try {
+    const uids = await listMessageUids(accessor, mailbox, query.criteria, budget);
+    headers = uids.length > 0 ? await fetchHeaders(accessor, mailbox, uids) : [];
+  } finally {
+    await accessor.close();
+  }
+  const pageOf = pageSlice(sortHeaders(headers, query.sorters), page, pageSize);
+  const out = messagesJsonBytes(pageOf);
+  return [out, new IOResult4()];
+}
+
+// src/commands/cli/builtin/himalaya/send.ts
+import {
+  FlagView as FlagView7,
+  IOResult as IOResult5,
+  materialize as materialize2
+} from "@struktoai/mirage-core";
+var ENC4 = new TextEncoder();
+async function send(inv) {
+  const inline = inv.texts.join(" ").replaceAll("\\r", "").replaceAll("\\n", "\n");
+  const raw = inline !== "" ? ENC4.encode(inline) : inv.stdin !== null ? await materialize2(inv.stdin) : new Uint8Array();
+  if (new TextDecoder().decode(raw).trim() === "") {
+    throw new Error("no message provided: pass it as an argument or pipe it via standard input");
+  }
+  const fl = new FlagView7(inv.flags);
+  const { parsed, warning } = await deliver(
+    inv.config,
+    raw,
+    fl.asStr("save") ?? null
+  );
+  const result = {
+    status: "sent",
+    to: parsed.to.map((entry) => entry.name === "" ? entry.email : `${entry.name} <${entry.email}>`).join(", "),
+    subject: parsed.subject
+  };
+  const out = ENC4.encode(JSON.stringify(result));
+  return [out, new IOResult5({ stderr: warning === "" ? null : ENC4.encode(warning) })];
+}
+
+// src/commands/cli/builtin/himalaya/index.ts
+var ID = new Operand({ type: "str" });
+var MAILBOX = new Option({
+  short: "-m",
+  long: "--mailbox",
+  type: "str",
+  description: "Mailbox name (default: INBOX)"
+});
+var PAGE = new Option({
+  short: "-p",
+  long: "--page",
+  type: "int",
+  description: "Page number, starting from 1"
+});
+var PAGE_SIZE = new Option({
+  short: "-s",
+  long: "--page-size",
+  type: "int",
+  description: "Maximum envelopes per page"
+});
+var SAVE = new Option({
+  long: "--save",
+  type: "str",
+  metavar: "MAILBOX",
+  description: "Append a copy of the message to this mailbox"
+});
+var COMPOSER = [
+  new Option({ long: "--from", type: "str", description: "Sender address" }),
+  new Option({
+    short: "-t",
+    long: "--to",
+    type: "str",
+    multiple: true,
+    description: "Recipient address(es), repeatable or comma-separated"
+  }),
+  new Option({
+    long: "--cc",
+    type: "str",
+    multiple: true,
+    description: "Carbon-copy recipient(s)"
+  }),
+  new Option({
+    long: "--bcc",
+    type: "str",
+    multiple: true,
+    description: "Blind carbon-copy recipient(s)"
+  }),
+  new Option({ short: "-s", long: "--subject", type: "str", description: "Subject line" }),
+  new Option({ long: "--body", type: "str", description: "Inline body (or pipe via stdin)" }),
+  new Option({
+    long: "--attach",
+    type: "path",
+    multiple: true,
+    description: "Attachment file(s), repeatable"
+  }),
+  new Option({
+    long: "--signature",
+    type: "str",
+    description: "Signature appended after a '-- ' line"
+  }),
+  new Option({
+    long: "--send",
+    description: "Send through SMTP instead of writing MIME to stdout"
+  }),
+  SAVE
+];
+var QUOTING = [
+  new Option({
+    short: "-P",
+    long: "--posting-style",
+    type: "str",
+    choices: ["top", "bottom"],
+    default: "top",
+    description: "Quoted source above or below your body"
+  }),
+  new Option({
+    short: "-Q",
+    long: "--quote-headline",
+    type: "str",
+    description: "Literal line placed before the quoted body"
+  })
+];
+var HIMALAYA = new CLISpec({
+  name: "himalaya",
+  description: "IMAP/SMTP mail client",
+  configModel: EmailConfigSchema,
+  subcommands: [
+    new CLISpec({
+      name: "envelope",
+      description: "Manage envelopes",
+      subcommands: [
+        new CLISpec({
+          name: "list",
+          aliases: ["ls"],
+          description: "List envelopes as JSON headers",
+          fn: listEnvelopes,
+          options: [MAILBOX, PAGE, PAGE_SIZE]
+        }),
+        new CLISpec({
+          name: "search",
+          aliases: ["sr"],
+          description: "Search envelopes with the query DSL",
+          fn: searchEnvelopes,
+          options: [MAILBOX, PAGE, PAGE_SIZE],
+          rest: ID,
+          epilog: "Conditions: date <yyyy-mm-dd>, before <yyyy-mm-dd>, after <yyyy-mm-dd>, from <pattern>, to <pattern>, subject <pattern>, body <pattern>, flag <seen|answered|flagged|draft|deleted>. Combine with and, or, not; group with parentheses. Sort with order by <date|from|to|subject> [asc|desc]."
+        })
+      ]
+    }),
+    new CLISpec({
+      name: "message",
+      description: "Manage messages",
+      subcommands: [
+        new CLISpec({
+          name: "read",
+          description: "Read one message as JSON",
+          fn: read,
+          options: [
+            MAILBOX,
+            new Option({ long: "--raw", description: "Write the RFC 5322 bytes instead" })
+          ],
+          rest: ID
+        }),
+        new CLISpec({
+          name: "compose",
+          aliases: ["write", "new"],
+          description: "Compose a new message from flags",
+          fn: compose,
+          write: true,
+          options: COMPOSER
+        }),
+        new CLISpec({
+          name: "send",
+          description: "Send a raw RFC 5322 message",
+          fn: send,
+          write: true,
+          options: [SAVE],
+          rest: ID
+        }),
+        new CLISpec({
+          name: "reply",
+          description: "Reply to a message",
+          fn: reply,
+          write: true,
+          options: [MAILBOX, ...COMPOSER, ...QUOTING],
+          rest: ID
+        }),
+        new CLISpec({
+          name: "forward",
+          aliases: ["fwd"],
+          description: "Forward a message",
+          fn: forward,
+          write: true,
+          options: [MAILBOX, ...COMPOSER, ...QUOTING],
+          rest: ID
+        })
+      ]
+    })
+  ]
+});
+registerCliSpec(HIMALAYA);
+
+// src/runtime/python/local.ts
+import { spawn } from "child_process";
+import {
+  HOME_CONFIG_KEYS,
+  PythonRuntime,
+  registerRuntime as registerRuntime2
+} from "@struktoai/mirage-core";
+var LOCAL_HOME_ENV = "MIRAGE_LOCAL_HOME";
+var LocalRuntime = class extends PythonRuntime {
+  name = "local";
+  // Spawns the host interpreter: a real process with the user's own
+  // filesystem and network, doors the workspace gate never sees. This
+  // is the base default; declared here so the claim is explicit at the
+  // one builtin runtime that voids a world's sandbox claim.
+  reach = "process";
+  python;
+  children = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    super(options, HOME_CONFIG_KEYS);
+    const home = this.config.home;
+    const chosen = home !== void 0 && home !== "" ? home : process.env[LOCAL_HOME_ENV];
+    this.python = chosen !== void 0 && chosen !== "" ? chosen : "python3";
+  }
+  run(args) {
+    return new Promise((resolve2, reject) => {
+      const child = spawn(this.python, ["-c", args.code, ...args.args], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...args.env },
+        ...args.signal !== void 0 ? { signal: args.signal, killSignal: "SIGKILL" } : {}
+      });
+      this.children.add(child);
+      const out = [];
+      const err = [];
+      child.stdout.on("data", (chunk) => out.push(chunk));
+      child.stderr.on("data", (chunk) => err.push(chunk));
+      child.on("error", (error) => {
+        if (error.name === "AbortError") return;
+        this.children.delete(child);
+        reject(
+          error.code === "ENOENT" ? new Error(
+            `local python interpreter not found: '${this.python}' (set the runtime entry's config home or ${LOCAL_HOME_ENV})`
+          ) : error
+        );
       });
-      this.db = await connect(this.config.uri, options);
-    }
-    return this.db;
-  }
-  async table(name) {
-    const cached = this.tables.get(name);
-    if (cached !== void 0) return cached;
-    const db = await this.connection();
-    const tbl = await db.openTable(name);
-    this.tables.set(name, tbl);
-    return tbl;
-  }
-  async listTables() {
-    const db = await this.connection();
-    const names = await db.tableNames();
-    return [...names].sort();
-  }
-  async distinct(table, column, filters, limit) {
-    const tbl = await this.table(table);
-    let query = tbl.query().select([column]).limit(limit);
-    if (Object.keys(filters).length > 0) query = query.where(whereClause(filters));
-    const rows = await query.toArray();
-    const values = /* @__PURE__ */ new Set();
-    for (const row of rows) {
-      const v = row[column];
-      if (v !== null && v !== void 0) values.add(toStr(v));
-    }
-    return [...values].sort();
-  }
-  async rowsMatching(table, filters, columns, limit) {
-    const tbl = await this.table(table);
-    let query = tbl.query().select(columns).limit(limit);
-    if (Object.keys(filters).length > 0) query = query.where(whereClause(filters));
-    return await query.toArray();
-  }
-  async rowRecord(table, idColumn, rowId) {
-    const tbl = await this.table(table);
-    const rows = await tbl.query().where(eqClause(idColumn, rowId)).limit(1).toArray();
-    return rows[0] ?? null;
-  }
-  async search(table, query, limit) {
-    const tbl = await this.table(table);
-    return await tbl.search(query).limit(limit).toArray();
+      child.on("close", (code) => {
+        this.children.delete(child);
+        const stderr = Buffer.concat(err);
+        resolve2({
+          stdout: new Uint8Array(Buffer.concat(out)),
+          stderr: stderr.length > 0 ? new Uint8Array(stderr) : null,
+          exitCode: code ?? 1
+        });
+      });
+      child.stdin.on("error", (error) => {
+        if (error.code !== "EPIPE") reject(error);
+      });
+      if (args.stdin !== null) child.stdin.write(args.stdin);
+      child.stdin.end();
+    });
   }
   close() {
-    if (this.db !== null) {
-      this.db.close();
-      this.db = null;
-    }
-    this.tables.clear();
+    for (const child of this.children) child.kill("SIGKILL");
+    this.children.clear();
     return Promise.resolve();
   }
 };
+registerRuntime2("local", LocalRuntime);
 
-// src/resource/lancedb/lancedb.ts
-var REMOTE_SCHEMES = ["s3://", "gs://", "az://", "hf://", "db://"];
-var LanceDBResource = class extends BaseResource {
-  kind = ResourceName.LANCEDB;
-  cachesReads;
-  indexTtl = 0;
-  prompt = LANCEDB_PROMPT;
-  config;
-  store;
-  accessor;
-  constructor(options) {
-    super();
-    const config = "config" in options ? options.config : options;
-    this.config = resolveLanceDBConfig(config);
-    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);
+// src/runtime/sandbox/e2b/runtime.ts
+import {
+  loadOptionalPeer as loadOptionalPeer4,
+  registerRuntime as registerRuntime3,
+  RemoteSandbox as RemoteSandbox2,
+  stdinPath as stdinPath2,
+  stdinRedirect as stdinRedirect2
+} from "@struktoai/mirage-core";
+
+// src/runtime/sandbox/e2b/config.ts
+var E2B_CONFIG_KEYS = ["env", "sandboxId", "apiKey"];
+
+// src/runtime/sandbox/e2b/runtime.ts
+var ENC5 = new TextEncoder();
+var E2BRuntime = class extends RemoteSandbox2 {
+  name = "e2b";
+  sdk = null;
+  sandbox = null;
+  constructor(options = {}) {
+    super(options, E2B_CONFIG_KEYS);
+    if (!this.config.sandboxId) {
+      throw new Error("e2b config needs sandboxId: the id of a live sandbox you created");
+    }
   }
-  open() {
-    return Promise.resolve();
+  // The SDK loader as a seam: tests substitute a fake module here.
+  loadSdk() {
+    return loadOptionalPeer4(() => import("e2b"), {
+      feature: "the 'e2b' runtime",
+      packageName: "e2b"
+    });
   }
-  async close() {
-    await this.store.close();
+  async ensureSdk() {
+    this.sdk ??= await this.loadSdk();
+    return this.sdk;
+  }
+  apiParams() {
+    return this.config.apiKey !== void 0 ? { apiKey: this.config.apiKey } : {};
+  }
+  async connect() {
+    const sdk = await this.ensureSdk();
+    this.sandbox = await sdk.Sandbox.connect(this.config.sandboxId, this.apiParams());
+  }
+  async execLine(line, stdin, env, cwd) {
+    if (this.sandbox === null) throw new Error("e2b sandbox not connected");
+    const sdk = await this.ensureSdk();
+    let command = line;
+    if (stdin !== null) {
+      const path4 = stdinPath2();
+      await this.upload(path4, stdin);
+      command = stdinRedirect2(line, path4);
+    }
+    let result;
+    try {
+      result = await this.sandbox.commands.run(command, { envs: env, cwd });
+    } catch (error) {
+      if (!(error instanceof sdk.CommandExitError)) throw error;
+      result = error;
+    }
+    return {
+      stdout: ENC5.encode(result.stdout),
+      stderr: ENC5.encode(result.stderr),
+      exitCode: result.exitCode
+    };
   }
-  ops() {
-    return LANCEDB_OPS;
+  async upload(path4, data) {
+    if (this.sandbox === null) throw new Error("e2b sandbox not connected");
+    const slash = path4.lastIndexOf("/");
+    const parent = slash > 0 ? path4.slice(0, slash) : "";
+    if (parent !== "") await this.sandbox.files.makeDir(parent);
+    await this.sandbox.files.write(path4, new Blob([data]));
   }
-  commands() {
-    return LANCEDB_COMMANDS;
+};
+registerRuntime3("e2b", E2BRuntime);
+
+// src/runtime/sandbox/docker/runtime.ts
+import { spawn as spawn2 } from "child_process";
+import {
+  registerRuntime as registerRuntime4,
+  RemoteSandbox as RemoteSandbox3
+} from "@struktoai/mirage-core";
+
+// src/runtime/sandbox/docker/config.ts
+var DOCKER_CONFIG_KEYS = ["env", "container"];
+
+// src/runtime/sandbox/docker/constants.ts
+var DOCKER_CLI_HINT = "the docker runtime needs the docker CLI on PATH (Docker Desktop, colima, or a podman alias)";
+
+// src/runtime/sandbox/docker/runtime.ts
+var DockerRuntime = class extends RemoteSandbox3 {
+  name = "docker";
+  constructor(options = {}) {
+    super(options, DOCKER_CONFIG_KEYS);
+    if (!this.config.container) {
+      throw new Error("docker config needs container: the id or name of a running container");
+    }
   }
-  readFile(p) {
-    return lanceRead(this.accessor, p, this.index);
+  // One docker CLI invocation; the seam tests override.
+  docker(args, stdin = null) {
+    return new Promise((resolve2, reject) => {
+      const child = spawn2("docker", args, { stdio: ["pipe", "pipe", "pipe"] });
+      const out = [];
+      const err = [];
+      child.stdout.on("data", (chunk) => out.push(chunk));
+      child.stderr.on("data", (chunk) => err.push(chunk));
+      child.on("error", (error) => {
+        reject(error.code === "ENOENT" ? new Error(DOCKER_CLI_HINT) : error);
+      });
+      child.on("close", (code) => {
+        resolve2({
+          stdout: new Uint8Array(Buffer.concat(out)),
+          stderr: new Uint8Array(Buffer.concat(err)),
+          code: code ?? 1
+        });
+      });
+      child.stdin.on("error", (error) => {
+        if (error.code !== "EPIPE") reject(error);
+      });
+      if (stdin !== null) child.stdin.write(stdin);
+      child.stdin.end();
+    });
   }
-  readdir(p) {
-    return lanceReaddir(this.accessor, p, this.index);
+  async connect() {
+    const result = await this.docker([
+      "inspect",
+      "--format",
+      "{{.State.Running}}",
+      this.config.container
+    ]);
+    if (result.code !== 0) {
+      throw new Error(`docker inspect failed: ${decode(result.stderr).trim()}`);
+    }
+    if (decode(result.stdout).trim() !== "true") {
+      throw new Error(`container ${this.config.container} is not running`);
+    }
   }
-  stat(p) {
-    return lanceStat(this.accessor, p, this.index);
+  async execLine(line, stdin, env, cwd) {
+    const args = ["exec", "-i", "-w", cwd];
+    for (const [key, value] of Object.entries(env)) args.push("-e", `${key}=${value}`);
+    args.push(this.config.container, "sh", "-c", line);
+    const result = await this.docker(args, stdin);
+    return { stdout: result.stdout, stderr: result.stderr, exitCode: result.code };
   }
 };
+var DECODER = new TextDecoder();
+function decode(bytes) {
+  return DECODER.decode(bytes);
+}
+registerRuntime4("docker", DockerRuntime);
 
 // src/resource/registry.ts
-import { normalizeFields } from "@struktoai/mirage-core";
+import {
+  normalizeFields,
+  compareCodePoints as compareCodePoints4
+} from "@struktoai/mirage-core";
 var REGISTRY = {
   ram: async (_config) => {
     const { RAMResource } = await import("@struktoai/mirage-core");
     return new RAMResource();
   },
   disk: async (config) => {
-    const { DiskResource: DiskResource2 } = await import("./disk-24NWTN2I.js");
+    const { DiskResource: DiskResource2 } = await import("./disk-WEHSTK3F.js");
     const norm = normalizeFields(config);
     return new DiskResource2(norm);
   },
   redis: async (config) => {
-    const { RedisResource: RedisResource2 } = await import("./redis-6D55Q2WB.js");
+    const { RedisResource: RedisResource2 } = await import("./redis-LPS357NF.js");
     const norm = normalizeFields(config);
     return new RedisResource2(norm);
   },
   s3: async (config) => {
-    const { S3Resource: S3Resource2 } = await import("./s3-XQBI2CXN.js");
-    const { normalizeS3Config } = await import("./config-BBOLI7VE.js");
-    return new S3Resource2(normalizeS3Config(config));
+    const { S3Resource: S3Resource2 } = await import("./s3-FPNWWIVM.js");
+    const { normalizeS3Config: normalizeS3Config2 } = await import("./config-G43HRUI3.js");
+    return new S3Resource2(normalizeS3Config2(config));
   },
   gridfs: async (config) => {
-    const { GridFSResource: GridFSResource2 } = await import("./gridfs-KZRZ6SIB.js");
-    const { normalizeGridFSConfig: normalizeGridFSConfig2 } = await import("./config-J2C53GOT.js");
+    const { GridFSResource: GridFSResource2 } = await import("./gridfs-CPLQ4G62.js");
+    const { normalizeGridFSConfig: normalizeGridFSConfig2 } = await import("./config-SYNEQAUB.js");
     return new GridFSResource2(normalizeGridFSConfig2(config));
   },
   gcs: async (config) => {
-    const { GCSResource: GCSResource2 } = await import("./gcs-PFWR6MIW.js");
-    const { normalizeGcsConfig } = await import("./config-BIBFLUIR.js");
+    const { GCSResource: GCSResource2 } = await import("./gcs-HFBIAE2C.js");
+    const { normalizeGcsConfig } = await import("./config-VPLHQXVE.js");
     return new GCSResource2(normalizeGcsConfig(config));
   },
   oci: async (config) => {
-    const { OCIResource: OCIResource2 } = await import("./oci-CKYBSFZJ.js");
-    const { normalizeOciConfig } = await import("./config-W7EVPJNK.js");
+    const { OCIResource: OCIResource2 } = await import("./oci-OQXOIC62.js");
+    const { normalizeOciConfig } = await import("./config-A25LTL5W.js");
     return new OCIResource2(normalizeOciConfig(config));
   },
   r2: async (config) => {
-    const { R2Resource: R2Resource2 } = await import("./r2-C4XGEWQY.js");
-    const { normalizeR2Config } = await import("./config-WVILHDFV.js");
+    const { R2Resource: R2Resource2 } = await import("./r2-FUA4IORE.js");
+    const { normalizeR2Config } = await import("./config-MDSAE4O3.js");
     return new R2Resource2(normalizeR2Config(config));
   },
   hf_buckets: async (config) => {
-    const { HfBucketsResource: HfBucketsResource2 } = await import("./hf_buckets-BK7NGJWS.js");
-    const { normalizeHfBucketsConfig: normalizeHfBucketsConfig2 } = await import("./config-SPW6NESU.js");
+    const { HfBucketsResource: HfBucketsResource2 } = await import("./hf_buckets-FTJITQ3P.js");
+    const { normalizeHfBucketsConfig: normalizeHfBucketsConfig2 } = await import("./config-LJ5T6TVA.js");
     return new HfBucketsResource2(normalizeHfBucketsConfig2(config));
   },
   hf_datasets: async (config) => {
-    const { HfDatasetsResource: HfDatasetsResource2 } = await import("./hf_datasets-UQ5QGM4L.js");
-    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-SPW6NESU.js");
+    const { HfDatasetsResource: HfDatasetsResource2 } = await import("./hf_datasets-6GXVKQD7.js");
+    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-LJ5T6TVA.js");
     return new HfDatasetsResource2(normalizeHfRepoConfig2(config));
   },
   hf_models: async (config) => {
-    const { HfModelsResource: HfModelsResource2 } = await import("./hf_models-75LFCQCS.js");
-    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-SPW6NESU.js");
+    const { HfModelsResource: HfModelsResource2 } = await import("./hf_models-PJPGZAC5.js");
+    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-LJ5T6TVA.js");
     return new HfModelsResource2(normalizeHfRepoConfig2(config));
   },
   hf_spaces: async (config) => {
-    const { HfSpacesResource: HfSpacesResource2 } = await import("./hf_spaces-6T2KB3UC.js");
-    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-SPW6NESU.js");
+    const { HfSpacesResource: HfSpacesResource2 } = await import("./hf_spaces-LFNFOLBF.js");
+    const { normalizeHfRepoConfig: normalizeHfRepoConfig2 } = await import("./config-LJ5T6TVA.js");
     return new HfSpacesResource2(normalizeHfRepoConfig2(config));
   },
   supabase: async (config) => {
-    const { SupabaseResource: SupabaseResource2 } = await import("./supabase-BBM44UTM.js");
-    const { normalizeSupabaseConfig } = await import("./config-EX3ZJTZI.js");
+    const { SupabaseResource: SupabaseResource2 } = await import("./supabase-A3KUFMDC.js");
+    const { normalizeSupabaseConfig } = await import("./config-FPC3RBFD.js");
     return new SupabaseResource2(normalizeSupabaseConfig(config));
   },
   databricks_volume: async (config) => {
-    const { DatabricksVolumeResource: DatabricksVolumeResource2 } = await import("./databricks_volume-ETRDJVVQ.js");
+    const { DatabricksVolumeResource: DatabricksVolumeResource2 } = await import("./databricks_volume-CNCPTZHS.js");
     const { normalizeDatabricksVolumeConfig } = await import("@struktoai/mirage-core");
     return DatabricksVolumeResource2.create(normalizeDatabricksVolumeConfig(config));
   },
   minio: async (config) => {
-    const { MinIOResource: MinIOResource2 } = await import("./minio-IZRZY4C5.js");
-    const { normalizeMinIOConfig } = await import("./config-2LASFFRD.js");
+    const { MinIOResource: MinIOResource2 } = await import("./minio-5SO6KBTK.js");
+    const { normalizeMinIOConfig } = await import("./config-5ZRKJTKG.js");
     return new MinIOResource2(normalizeMinIOConfig(config));
   },
   ceph: async (config) => {
-    const { CephResource: CephResource2 } = await import("./ceph-C265UI5T.js");
-    const { normalizeCephConfig } = await import("./config-54USUVSE.js");
+    const { CephResource: CephResource2 } = await import("./ceph-ALKLD3MO.js");
+    const { normalizeCephConfig } = await import("./config-QY4IL3PH.js");
     return new CephResource2(normalizeCephConfig(config));
   },
   seaweedfs: async (config) => {
-    const { SeaweedFSResource: SeaweedFSResource2 } = await import("./seaweedfs-3XYIAFU2.js");
-    const { normalizeSeaweedFSConfig } = await import("./config-OJ2BPESH.js");
+    const { SeaweedFSResource: SeaweedFSResource2 } = await import("./seaweedfs-MC6HIEP4.js");
+    const { normalizeSeaweedFSConfig } = await import("./config-WVHKXEVE.js");
     return new SeaweedFSResource2(normalizeSeaweedFSConfig(config));
   },
   wasabi: async (config) => {
-    const { WasabiResource: WasabiResource2 } = await import("./wasabi-O4MVIUFG.js");
-    const { normalizeWasabiConfig } = await import("./config-T2IUIU5C.js");
+    const { WasabiResource: WasabiResource2 } = await import("./wasabi-2IKBIWNO.js");
+    const { normalizeWasabiConfig } = await import("./config-2YBCHU2W.js");
     return new WasabiResource2(normalizeWasabiConfig(config));
   },
   backblaze: async (config) => {
-    const { BackblazeResource: BackblazeResource2 } = await import("./backblaze-TSPL6Y56.js");
-    const { normalizeBackblazeConfig } = await import("./config-QO2XUME4.js");
+    const { BackblazeResource: BackblazeResource2 } = await import("./backblaze-4EKSW63F.js");
+    const { normalizeBackblazeConfig } = await import("./config-GG3WO5PB.js");
     return new BackblazeResource2(normalizeBackblazeConfig(config));
   },
   digitalocean: async (config) => {
-    const { DigitalOceanResource: DigitalOceanResource2 } = await import("./digitalocean-QP72DR4J.js");
-    const { normalizeDigitalOceanConfig } = await import("./config-XU6D5C7E.js");
+    const { DigitalOceanResource: DigitalOceanResource2 } = await import("./digitalocean-DJZOUB6Q.js");
+    const { normalizeDigitalOceanConfig } = await import("./config-TJKGYA2B.js");
     return new DigitalOceanResource2(normalizeDigitalOceanConfig(config));
   },
   tencent: async (config) => {
-    const { TencentResource: TencentResource2 } = await import("./tencent-X72USLJ7.js");
-    const { normalizeTencentConfig } = await import("./config-FRK7ZL37.js");
+    const { TencentResource: TencentResource2 } = await import("./tencent-5464UQ2X.js");
+    const { normalizeTencentConfig } = await import("./config-RIAAD6RW.js");
     return new TencentResource2(normalizeTencentConfig(config));
   },
   aliyun: async (config) => {
-    const { AliyunResource: AliyunResource2 } = await import("./aliyun-PGI57A43.js");
-    const { normalizeAliyunConfig } = await import("./config-IPNWAJHH.js");
+    const { AliyunResource: AliyunResource2 } = await import("./aliyun-S62BR3TB.js");
+    const { normalizeAliyunConfig } = await import("./config-G3F54CS4.js");
     return new AliyunResource2(normalizeAliyunConfig(config));
   },
   scaleway: async (config) => {
-    const { ScalewayResource: ScalewayResource2 } = await import("./scaleway-SEZJVURB.js");
-    const { normalizeScalewayConfig } = await import("./config-CPYFOUQO.js");
+    const { ScalewayResource: ScalewayResource2 } = await import("./scaleway-BP3732U7.js");
+    const { normalizeScalewayConfig } = await import("./config-XU7R36IE.js");
     return new ScalewayResource2(normalizeScalewayConfig(config));
   },
   qingstor: async (config) => {
-    const { QingStorResource: QingStorResource2 } = await import("./qingstor-AP4IIPLY.js");
-    const { normalizeQingStorConfig } = await import("./config-M3Z47VYU.js");
+    const { QingStorResource: QingStorResource2 } = await import("./qingstor-W277YA4K.js");
+    const { normalizeQingStorConfig } = await import("./config-3YRGRW72.js");
     return new QingStorResource2(normalizeQingStorConfig(config));
   },
   postgres: async (config) => {
-    const { PostgresResource: PostgresResource2 } = await import("./postgres-WIQBVL5M.js");
+    const { PostgresResource: PostgresResource2 } = await import("./postgres-AV45GNRS.js");
     const { normalizePostgresConfig } = await import("@struktoai/mirage-core");
     return new PostgresResource2(normalizePostgresConfig(config));
   },
   mongodb: async (config) => {
-    const { MongoDBResource: MongoDBResource2 } = await import("./mongodb-VMKPQCPX.js");
+    const { MongoDBResource: MongoDBResource2 } = await import("./mongodb-L5CMN2EE.js");
     const { normalizeMongoDBConfig } = await import("@struktoai/mirage-core");
     return new MongoDBResource2(normalizeMongoDBConfig(config));
   },
+  chroma: async (config) => {
+    const { ChromaResource } = await import("@struktoai/mirage-core");
+    return new ChromaResource(normalizeFields(config));
+  },
+  dify: async (config) => {
+    const { DifyResource } = await import("@struktoai/mirage-core");
+    return new DifyResource(normalizeFields(config));
+  },
+  qdrant: async (config) => {
+    const { QdrantResource } = await import("@struktoai/mirage-core");
+    return new QdrantResource(normalizeFields(config));
+  },
+  lancedb: async (config) => {
+    const { LanceDBResource: LanceDBResource2 } = await import("./lancedb-TJ5YSJY5.js");
+    return new LanceDBResource2(normalizeFields(config));
+  },
   slack: async (config) => {
-    const { SlackResource: SlackResource2 } = await import("./slack-ZHXDJQY4.js");
-    const { normalizeSlackConfig: normalizeSlackConfig2 } = await import("./config-4QV4QYI5.js");
+    const { SlackResource: SlackResource2 } = await import("./slack-JFGW7VLN.js");
+    const { normalizeSlackConfig: normalizeSlackConfig2 } = await import("@struktoai/mirage-core");
     return new SlackResource2(normalizeSlackConfig2(config));
   },
   ssh: async (config) => {
-    const { SSHResource: SSHResource2 } = await import("./ssh-X2MO7JOV.js");
-    const { normalizeSshConfig: normalizeSshConfig2 } = await import("./config-VKKZGC7V.js");
+    const { SSHResource: SSHResource2 } = await import("./ssh-UYPG42LM.js");
+    const { normalizeSshConfig: normalizeSshConfig2 } = await import("./config-R4LAOEDS.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");
+    const { NextcloudResource: NextcloudResource2 } = await import("./nextcloud-4O2LZVW2.js");
+    const { normalizeNextcloudConfig: normalizeNextcloudConfig2 } = await import("./config-D2RF7L3N.js");
     return new NextcloudResource2(normalizeNextcloudConfig2(config));
   },
   discord: async (config) => {
-    const { DiscordResource: DiscordResource2 } = await import("./discord-BSN5RB3E.js");
-    const { normalizeDiscordConfig: normalizeDiscordConfig2 } = await import("./config-EHE52ZTK.js");
+    const { DiscordResource: DiscordResource2 } = await import("./discord-ETB2CADR.js");
+    const { normalizeDiscordConfig: normalizeDiscordConfig2 } = await import("@struktoai/mirage-core");
     return new DiscordResource2(normalizeDiscordConfig2(config));
   },
   trello: async (config) => {
-    const { TrelloResource: TrelloResource2 } = await import("./trello-EER5NG7L.js");
-    const { normalizeTrelloConfig: normalizeTrelloConfig2 } = await import("./config-QWQGOXQ5.js");
+    const { TrelloResource: TrelloResource2 } = await import("./trello-O2KB3FUO.js");
+    const { normalizeTrelloConfig: normalizeTrelloConfig2 } = await import("./config-JUYBWAZE.js");
     return new TrelloResource2(normalizeTrelloConfig2(config));
   },
   linear: async (config) => {
-    const { LinearResource: LinearResource2 } = await import("./linear-V3TXO6CV.js");
-    const { normalizeLinearConfig: normalizeLinearConfig2 } = await import("./config-LEALEMKA.js");
+    const { LinearResource: LinearResource2 } = await import("./linear-BCE4KEAC.js");
+    const { normalizeLinearConfig: normalizeLinearConfig2 } = await import("@struktoai/mirage-core");
     return new LinearResource2(normalizeLinearConfig2(config));
   },
   notion: async (config) => {
-    const { NotionResource: NotionResource2 } = await import("./notion-6PPNTQFM.js");
-    const { normalizeNotionConfig: normalizeNotionConfig2 } = await import("./config-HTXOOAOD.js");
+    const { NotionResource: NotionResource2 } = await import("./notion-RVKEAQ2M.js");
+    const { normalizeNotionConfig: normalizeNotionConfig2 } = await import("@struktoai/mirage-core");
     return new NotionResource2(normalizeNotionConfig2(config));
   },
   langfuse: async (config) => {
-    const { LangfuseResource: LangfuseResource2 } = await import("./langfuse-AMQCQWNE.js");
-    const { normalizeLangfuseConfig: normalizeLangfuseConfig2 } = await import("./config-HQXNFQZS.js");
+    const { LangfuseResource: LangfuseResource2 } = await import("./langfuse-RUMTUMXS.js");
+    const { normalizeLangfuseConfig: normalizeLangfuseConfig2 } = await import("./config-E55TKM6K.js");
     return new LangfuseResource2(normalizeLangfuseConfig2(config));
   },
+  jaeger: async (config) => {
+    const { JaegerResource: JaegerResource2 } = await import("./jaeger-GCA6MJ6E.js");
+    const { normalizeJaegerConfig } = await import("./config-PB3KA2CE.js");
+    return new JaegerResource2(normalizeJaegerConfig(config));
+  },
   github: async (config) => {
-    const { GitHubResource: GitHubResource2 } = await import("./github-EQ4NXUTA.js");
-    const { normalizeGitHubConfig: normalizeGitHubConfig2 } = await import("./config-WKQ3FGTZ.js");
+    const { GitHubResource: GitHubResource2 } = await import("./github-BPZREGPI.js");
+    const { normalizeGitHubConfig: normalizeGitHubConfig2 } = await import("./config-CLU7JABG.js");
     return GitHubResource2.create(normalizeGitHubConfig2(config));
   },
   github_ci: async (config) => {
-    const { GitHubCIResource: GitHubCIResource2 } = await import("./github_ci-QL5B2Q2N.js");
-    const { normalizeGitHubCIConfig: normalizeGitHubCIConfig2 } = await import("./config-MZM3IPFM.js");
+    const { GitHubCIResource: GitHubCIResource2 } = await import("./github_ci-7A4LUIZ7.js");
+    const { normalizeGitHubCIConfig: normalizeGitHubCIConfig2 } = await import("./config-NRIOKK5T.js");
     return new GitHubCIResource2(normalizeGitHubCIConfig2(config));
   },
+  gcal: async (config) => {
+    const { GCalResource: GCalResource2 } = await import("./gcal-P56MRCGU.js");
+    const { normalizeGCalConfig } = await import("./config-4GSOMUMF.js");
+    return new GCalResource2(normalizeGCalConfig(config));
+  },
   gdocs: async (config) => {
-    const { GDocsResource: GDocsResource2 } = await import("./gdocs-GPAZRQG5.js");
-    const { normalizeGDocsConfig: normalizeGDocsConfig2 } = await import("./config-3WDIJPTG.js");
-    return new GDocsResource2(normalizeGDocsConfig2(config));
+    const { GDocsResource: GDocsResource2 } = await import("./gdocs-LQ3UXP3J.js");
+    const { normalizeGDocsConfig } = await import("./config-WRACCRPN.js");
+    return new GDocsResource2(normalizeGDocsConfig(config));
   },
   gsheets: async (config) => {
-    const { GSheetsResource: GSheetsResource2 } = await import("./gsheets-N53WEXN2.js");
-    const { normalizeGSheetsConfig: normalizeGSheetsConfig2 } = await import("./config-5ZXN2T2H.js");
-    return new GSheetsResource2(normalizeGSheetsConfig2(config));
+    const { GSheetsResource: GSheetsResource2 } = await import("./gsheets-4BNIJPQ6.js");
+    const { normalizeGSheetsConfig } = await import("./config-5YBUWFUP.js");
+    return new GSheetsResource2(normalizeGSheetsConfig(config));
   },
   gslides: async (config) => {
-    const { GSlidesResource: GSlidesResource2 } = await import("./gslides-TATSARTH.js");
-    const { normalizeGSlidesConfig: normalizeGSlidesConfig2 } = await import("./config-RI7IEZUF.js");
-    return new GSlidesResource2(normalizeGSlidesConfig2(config));
+    const { GSlidesResource: GSlidesResource2 } = await import("./gslides-GDBYLO5A.js");
+    const { normalizeGSlidesConfig } = await import("./config-ELDOFRJW.js");
+    return new GSlidesResource2(normalizeGSlidesConfig(config));
   },
   gdrive: async (config) => {
-    const { GDriveResource: GDriveResource2 } = await import("./gdrive-XSX6A7B3.js");
-    const { normalizeGDriveConfig: normalizeGDriveConfig2 } = await import("./config-K63RX6EU.js");
-    return new GDriveResource2(normalizeGDriveConfig2(config));
+    const { GDriveResource: GDriveResource2 } = await import("./gdrive-N6UBYLON.js");
+    const { normalizeGDriveConfig } = await import("./config-FPM3LAW7.js");
+    return new GDriveResource2(normalizeGDriveConfig(config));
+  },
+  onedrive: async (config) => {
+    const { OneDriveResource: OneDriveResource2, normalizeOneDriveConfig } = await import("@struktoai/mirage-core");
+    return new OneDriveResource2(normalizeOneDriveConfig(config));
+  },
+  sharepoint: async (config) => {
+    const { SharePointResource: SharePointResource2, normalizeSharePointConfig } = await import("@struktoai/mirage-core");
+    return new SharePointResource2(normalizeSharePointConfig(config));
+  },
+  mem0: async (config) => {
+    const { Mem0Resource: Mem0Resource2, normalizeMem0Config } = await import("@struktoai/mirage-core");
+    return new Mem0Resource2(normalizeMem0Config(config));
   },
   dropbox: async (config) => {
-    const { DropboxResource: DropboxResource2 } = await import("./dropbox-OSTZXSIE.js");
-    const { normalizeDropboxConfig: normalizeDropboxConfig2 } = await import("./config-L7SBSH5L.js");
+    const { DropboxResource: DropboxResource2 } = await import("./dropbox-XN6PGLNE.js");
+    const { normalizeDropboxConfig: normalizeDropboxConfig2 } = await import("./config-OYK2BSJK.js");
     return new DropboxResource2(normalizeDropboxConfig2(config));
   },
   box: async (config) => {
-    const { BoxResource: BoxResource2 } = await import("./box-7XTZYDSO.js");
-    const { normalizeBoxConfig: normalizeBoxConfig2 } = await import("./config-A2GQYJDB.js");
+    const { BoxResource: BoxResource2 } = await import("./box-ZPLZAGMK.js");
+    const { normalizeBoxConfig: normalizeBoxConfig2 } = await import("./config-Y2KOUYSS.js");
     return new BoxResource2(normalizeBoxConfig2(config));
   },
   gmail: async (config) => {
-    const { GmailResource: GmailResource2 } = await import("./gmail-2TBT4CVH.js");
+    const { GmailResource: GmailResource2 } = await import("./gmail-YED2MF6H.js");
     const { normalizeGmailConfig } = await import("./config-UU27ALAA.js");
     return new GmailResource2(normalizeGmailConfig(config));
   },
   email: async (config) => {
-    const { EmailResource: EmailResource2 } = await import("./email-4ZFPSWIN.js");
-    const { normalizeEmailConfig: normalizeEmailConfig2 } = await import("./config-DWSJL3NH.js");
+    const { EmailResource: EmailResource2 } = await import("./email-OV7XCP3T.js");
+    const { normalizeEmailConfig: normalizeEmailConfig2 } = await import("./config-UURRGA7U.js");
     return new EmailResource2(normalizeEmailConfig2(config));
   }
 };
+var CUSTOM = {};
 function knownResources() {
-  return Object.keys(REGISTRY).sort();
+  return [.../* @__PURE__ */ new Set([...Object.keys(REGISTRY), ...Object.keys(CUSTOM)])].sort(compareCodePoints4);
 }
 function register(name, factory) {
-  REGISTRY[name] = factory;
+  if (name in REGISTRY) throw new Error(`cannot register '${name}': shadows a builtin`);
+  CUSTOM[name] = factory;
 }
 async function buildResource(name, config = {}) {
-  const factory = REGISTRY[name];
+  const factory = REGISTRY[name] ?? CUSTOM[name];
   if (factory === void 0) {
     throw new Error(
       `unknown resource ${JSON.stringify(name)}; known: ${knownResources().join(", ")}`
@@ -2838,6 +4337,62 @@ async function buildResource(name, config = {}) {
   }
   return factory(config);
 }
+
+// src/resource/loader.ts
+import { existsSync } from "fs";
+import { isAbsolute, resolve } from "path";
+import { pathToFileURL } from "url";
+var MODULE_SUFFIXES = [".mjs", ".cjs", ".mts", ".cts", ".js", ".ts"];
+function isModulePath(source) {
+  if (source.startsWith("./") || source.startsWith("../")) return true;
+  if (source.startsWith("/") || isAbsolute(source)) return true;
+  if (source.includes("/")) return false;
+  return MODULE_SUFFIXES.some((suffix) => source.endsWith(suffix));
+}
+function splitRef(spec) {
+  const cut = spec.lastIndexOf(":");
+  if (cut < 0) {
+    throw new Error(`invalid ref ${JSON.stringify(spec)}, expected 'source:ExportName'`);
+  }
+  return [spec.slice(0, cut), spec.slice(cut + 1)];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isNotFound(error) {
+  if (!isRecord(error)) return false;
+  return error.code === "ERR_MODULE_NOT_FOUND" || error.code === "ENOENT";
+}
+function isUnsupportedTypeScript(error) {
+  return isRecord(error) && error.code === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX";
+}
+async function loadAttr(spec) {
+  const [source, attr] = splitRef(spec);
+  const path4 = isModulePath(source) ? isAbsolute(source) ? source : resolve(source) : null;
+  if (path4 !== null && !existsSync(path4)) {
+    throw new Error(`cannot load script ${JSON.stringify(source)}`);
+  }
+  const target = path4 !== null ? pathToFileURL(path4).href : source;
+  let mod;
+  try {
+    mod = await import(target);
+  } catch (error) {
+    if (path4 === null && isNotFound(error)) {
+      throw new Error(`cannot load script ${JSON.stringify(source)}`);
+    }
+    if (isUnsupportedTypeScript(error)) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `cannot load script ${JSON.stringify(source)}: ${detail}. Node strips types without compiling them; precompile the file or ship it as .mjs.`
+      );
+    }
+    throw error;
+  }
+  if (attr in mod) return mod[attr];
+  const fallback = mod.default;
+  if (isRecord(fallback) && attr in fallback) return fallback[attr];
+  throw new Error(`${JSON.stringify(attr)} not found in ${JSON.stringify(source)}`);
+}
 export {
   ALIYUN_PROMPT,
   AliyunResource,
@@ -2846,12 +4401,15 @@ export {
   BoxResource,
   CEPH_PROMPT,
   CephResource,
+  DAYTONA_CONFIG_KEYS,
   DEFAULT_STATE_ROOT,
   DIGITALOCEAN_PROMPT,
   DISK_COMMANDS,
   DISK_OPS,
   DISK_PROMPT,
+  DOCKER_CONFIG_KEYS,
   DatabricksVolumeResource,
+  DaytonaRuntime,
   DigitalOceanResource,
   DiscordResource,
   DiskNamespaceStore,
@@ -2860,19 +4418,25 @@ export {
   DiskResource,
   DiskSessionStore,
   DiskWorkspaceStateStore,
+  DockerRuntime,
   DropboxResource,
+  E2BRuntime,
+  E2B_CONFIG_KEYS,
   EMAIL_COMMANDS,
   EMAIL_OPS,
   EMAIL_PROMPT,
   EMAIL_WRITE_PROMPT,
   EmailAccessor,
   EmailResource,
+  FSKIT_MOUNT_ROOT,
   FuseManager,
   GCSResource,
   GCS_ENDPOINT,
   GCS_PROMPT,
+  GCalResource,
   GDocsResource,
   GDriveResource,
+  GRIDFS_COMMANDS,
   GSheetsResource,
   GSlidesResource,
   GitHubCIResource,
@@ -2888,6 +4452,7 @@ export {
   HF_OPS,
   HF_RESOURCES,
   HF_SPACES_PROMPT,
+  HIMALAYA,
   HfAccessor,
   HfBucketsAccessor,
   HfBucketsResource,
@@ -2897,24 +4462,31 @@ export {
   HfModelsResource,
   HfSpacesAccessor,
   HfSpacesResource,
+  JaegerResource,
   LanceDBResource,
   LanceDBStore,
   LangfuseResource,
   LinearResource,
+  LocalRuntime,
   MINIO_PROMPT,
+  MODULE_SUFFIXES,
+  Mem0Resource,
   MinIOResource,
   MirageFS,
   MongoDBResource,
   MongoDBStore,
   Mount,
+  MountCore,
   NEXTCLOUD_COMMANDS,
   NEXTCLOUD_OPS,
   NEXTCLOUD_PROMPT,
   NextcloudAccessor,
   NextcloudResource,
+  NextcloudWalk,
   NotionResource,
   OCIResource,
   OCI_PROMPT,
+  OneDriveResource,
   PostgresResource,
   PostgresStore,
   QINGSTOR_PROMPT,
@@ -2925,6 +4497,7 @@ export {
   REDIS_OPS,
   REDIS_PROMPT,
   RedisAccessor,
+  RedisConsoleStore,
   RedisFileCacheStore,
   RedisNamespaceStore,
   RedisObserverStore,
@@ -2943,6 +4516,7 @@ export {
   SUPABASE_PROMPT,
   ScalewayResource,
   SeaweedFSResource,
+  SharePointResource,
   SlackResource,
   SupabaseResource,
   TENCENT_PROMPT,
@@ -2953,26 +4527,35 @@ export {
   Workspace,
   assertHfRepoId,
   buildEmailConfig,
+  buildDeltaHook as buildNextcloudDeltaHook,
   buildResource,
+  checkMountpoint,
+  checkPlatform,
+  checkSizes,
+  classifyErrno,
+  classifyError,
   fileReadProvision,
   mount as fuseMount,
   mountBackground as fuseMountBackground,
   headTailProvision,
   isMacosMetadata,
+  isModulePath,
   knownResources,
+  loadAttr,
   loadDatabricksProfile,
   metadataProvision,
   normalizeBoxConfig,
   normalizeDiscordConfig,
   normalizeDropboxConfig,
   normalizeEmailConfig,
-  normalizeGDocsConfig,
-  normalizeGDriveConfig,
-  normalizeGSheetsConfig,
-  normalizeGSlidesConfig,
+  normalizeGoogleConfig6 as normalizeGCalConfig,
+  normalizeGoogleConfig as normalizeGDocsConfig,
+  normalizeGoogleConfig4 as normalizeGDriveConfig,
+  normalizeGoogleConfig2 as normalizeGSheetsConfig,
+  normalizeGoogleConfig3 as normalizeGSlidesConfig,
   normalizeGitHubCIConfig,
   normalizeGitHubConfig,
-  normalizeGoogleConfig as normalizeGmailConfig,
+  normalizeGoogleConfig5 as normalizeGmailConfig,
   normalizeGridFSConfig,
   normalizeHfBucketsConfig,
   normalizeHfModelsConfig,
@@ -2981,11 +4564,13 @@ export {
   normalizeLinearConfig,
   normalizeNextcloudConfig,
   normalizeNotionConfig,
+  normalizeS3Config,
   normalizeSlackConfig,
   normalizeSshConfig,
   normalizeTrelloConfig,
   parseDatabricksCfg,
   patchNodeFs,
+  prepareBackend,
   redactAliyunConfig,
   redactBackblazeConfig,
   redactBoxConfig,
@@ -2994,14 +4579,15 @@ export {
   redactDiscordConfig,
   redactDropboxConfig,
   redactEmailConfig,
-  redactGDocsConfig,
-  redactGDriveConfig,
-  redactGSheetsConfig,
-  redactGSlidesConfig,
+  redactGoogleConfig6 as redactGCalConfig,
+  redactGoogleConfig as redactGDocsConfig,
+  redactGoogleConfig4 as redactGDriveConfig,
+  redactGoogleConfig2 as redactGSheetsConfig,
+  redactGoogleConfig3 as redactGSlidesConfig,
   redactGcsConfig,
   redactGitHubCIConfig,
   redactGitHubConfig,
-  redactGoogleConfig as redactGmailConfig,
+  redactGoogleConfig5 as redactGmailConfig,
   redactHfBucketsConfig,
   redactHfModelsConfig,
   redactHfRepoConfig,
@@ -3023,6 +4609,8 @@ export {
   redactTrelloConfig,
   redactWasabiConfig,
   register as registerResourceFactory,
+  requireKernelBackend,
+  resolveBackend,
   resolvedAliyunEndpoint,
   resolvedBackblazeEndpoint,
   resolvedDigitalOceanEndpoint,
@@ -3030,6 +4618,8 @@ export {
   resolvedScalewayEndpoint,
   resolvedSupabaseEndpoint,
   resolvedTencentEndpoint,
-  resolvedWasabiEndpoint
+  resolvedWasabiEndpoint,
+  splitRef,
+  unsizedMounts
 };
 //# sourceMappingURL=index.js.map