@struktoai/mirage-node 0.0.1-alpha.1

package/dist/index.js

@@ -0,0 +1,3564 @@
+import {
+  DropboxResource
+} from "./chunk-5E6BULAK.js";
+import {
+  BoxResource
+} from "./chunk-6M2NL363.js";
+import {
+  normalizeBoxConfig,
+  redactBoxConfig
+} from "./chunk-EKPH4MMD.js";
+import {
+  GmailResource
+} from "./chunk-UWMOTOXA.js";
+import {
+  normalizeGmailConfig,
+  redactGmailConfig
+} from "./chunk-GO67AOYK.js";
+import {
+  EMAIL_COMMANDS,
+  EMAIL_OPS,
+  EMAIL_PROMPT,
+  EMAIL_WRITE_PROMPT,
+  EmailAccessor,
+  EmailResource
+} from "./chunk-OYJXYJTE.js";
+import {
+  buildEmailConfig,
+  normalizeEmailConfig,
+  redactEmailConfig
+} from "./chunk-H74QYTN7.js";
+import {
+  GDocsResource
+} from "./chunk-NOZZFJEB.js";
+import {
+  GSheetsResource
+} from "./chunk-3PBSL7BS.js";
+import {
+  normalizeGSheetsConfig,
+  redactGSheetsConfig
+} from "./chunk-I4RRGZGB.js";
+import {
+  GSlidesResource
+} from "./chunk-XDEEOTVK.js";
+import {
+  normalizeGSlidesConfig,
+  redactGSlidesConfig
+} from "./chunk-5ITBZN55.js";
+import {
+  GDriveResource
+} from "./chunk-MVE5VVMQ.js";
+import {
+  normalizeGDriveConfig,
+  redactGDriveConfig
+} from "./chunk-35PVZRWU.js";
+import {
+  normalizeDropboxConfig,
+  redactDropboxConfig
+} from "./chunk-RQYYYBQG.js";
+import {
+  LinearResource
+} from "./chunk-UZZD4MRJ.js";
+import {
+  LangfuseResource
+} from "./chunk-DCJQ2PIX.js";
+import {
+  normalizeLangfuseConfig,
+  redactLangfuseConfig
+} from "./chunk-6M3QVVOH.js";
+import {
+  GitHubResource
+} from "./chunk-PEZYBKZH.js";
+import {
+  normalizeGitHubConfig,
+  redactGitHubConfig
+} from "./chunk-VCLMTMSO.js";
+import {
+  GitHubCIResource
+} from "./chunk-GCB4JUF7.js";
+import {
+  normalizeGitHubCIConfig,
+  redactGitHubCIConfig
+} from "./chunk-GPF66TH2.js";
+import {
+  normalizeGDocsConfig,
+  redactGDocsConfig
+} from "./chunk-3Y625AUP.js";
+import {
+  SlackResource
+} from "./chunk-V5OLWE7F.js";
+import {
+  SSHAccessor,
+  SSHResource,
+  SSH_COMMANDS,
+  SSH_OPS,
+  SSH_PROMPT
+} from "./chunk-M42JTWPR.js";
+import {
+  normalizeSshConfig,
+  redactSshConfig
+} from "./chunk-FZ2GJ4BJ.js";
+import {
+  DiscordResource
+} from "./chunk-WSDQ2MRG.js";
+import {
+  normalizeDiscordConfig,
+  redactDiscordConfig
+} from "./chunk-XVYZO2FG.js";
+import {
+  TrelloResource
+} from "./chunk-LBBM3LKK.js";
+import {
+  normalizeTrelloConfig,
+  redactTrelloConfig
+} from "./chunk-QWWOBAYU.js";
+import {
+  normalizeLinearConfig,
+  redactLinearConfig
+} from "./chunk-6Y6GWMFF.js";
+import {
+  OCIResource,
+  OCI_PROMPT
+} from "./chunk-HXWGG4K7.js";
+import {
+  R2Resource,
+  R2_PROMPT
+} from "./chunk-ICSS5ETT.js";
+import {
+  redactR2Config
+} from "./chunk-6VKNSO6U.js";
+import {
+  SUPABASE_PROMPT,
+  SupabaseResource
+} from "./chunk-HEQL3LPK.js";
+import {
+  redactSupabaseConfig,
+  resolvedSupabaseEndpoint
+} from "./chunk-ALAMUIGJ.js";
+import {
+  PostgresResource,
+  PostgresStore
+} from "./chunk-XQUQSNCA.js";
+import {
+  MongoDBResource,
+  MongoDBStore
+} from "./chunk-7QXJ4KWQ.js";
+import {
+  normalizeSlackConfig,
+  redactSlackConfig
+} from "./chunk-KINMBZHC.js";
+import {
+  DISK_COMMANDS,
+  DISK_OPS,
+  DISK_PROMPT,
+  DiskResource,
+  stat,
+  stream
+} from "./chunk-GKQNMLQU.js";
+import "./chunk-U6QSXTUS.js";
+import {
+  REDIS_COMMANDS,
+  REDIS_OPS,
+  REDIS_PROMPT,
+  RedisAccessor,
+  RedisResource,
+  RedisStore,
+  loadOptionalPeer,
+  stat as stat2
+} from "./chunk-T2WWAEKH.js";
+import {
+  GCSResource,
+  GCS_PROMPT
+} from "./chunk-MY3NUJJD.js";
+import {
+  S3Resource
+} from "./chunk-G7O6DAWU.js";
+import {
+  redactConfig
+} from "./chunk-LPMPTQYP.js";
+import {
+  GCS_ENDPOINT,
+  redactGcsConfig
+} from "./chunk-H3JR7MN3.js";
+import {
+  redactOciConfig
+} from "./chunk-ZC4KNEOQ.js";
+
+// src/index.ts
+export * from "@struktoai/mirage-core";
+
+// src/workspace.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import {
+  createShellParser,
+  ExecuteResult as ExecuteResult2,
+  Workspace as CoreWorkspace
+} from "@struktoai/mirage-core";
+
+// src/native.ts
+import { spawn } from "child_process";
+import { ExecuteResult } from "@struktoai/mirage-core";
+function concatChunks(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+function nativeExec(command31, options) {
+  return new Promise((resolve, reject) => {
+    const env = options.env ?? process.env;
+    const spawnOpts = {
+      cwd: options.cwd,
+      env
+    };
+    if (options.signal !== void 0) spawnOpts.signal = options.signal;
+    const proc = spawn("sh", ["-c", command31], spawnOpts);
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let killed = false;
+    const timeoutMs = options.timeoutMs ?? null;
+    const timer = timeoutMs !== null ? setTimeout(() => {
+      killed = true;
+      proc.kill("SIGKILL");
+      proc.stdout.destroy();
+      proc.stderr.destroy();
+    }, timeoutMs) : null;
+    proc.stdout.on("data", (chunk) => {
+      stdoutChunks.push(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderrChunks.push(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+    });
+    proc.on("error", (err) => {
+      if (timer !== null) clearTimeout(timer);
+      if (err.name === "AbortError" || options.signal?.aborted === true) {
+        reject(new DOMException("execute aborted", "AbortError"));
+        return;
+      }
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      if (timer !== null) clearTimeout(timer);
+      if (options.signal?.aborted === true) {
+        reject(new DOMException("execute aborted", "AbortError"));
+        return;
+      }
+      if (killed) {
+        resolve(new ExecuteResult(new Uint8Array(), new TextEncoder().encode("timeout\n"), 124));
+        return;
+      }
+      resolve(new ExecuteResult(concatChunks(stdoutChunks), concatChunks(stderrChunks), code ?? 0));
+    });
+  });
+}
+function nativeExecStream(command31, options) {
+  const env = options.env ?? process.env;
+  const spawnOpts = {
+    cwd: options.cwd,
+    env
+  };
+  const proc = spawn("sh", ["-c", command31], spawnOpts);
+  return {
+    raw: proc,
+    stdoutStream() {
+      return proc.stdout;
+    },
+    stderrStream() {
+      return proc.stderr;
+    },
+    wait() {
+      return new Promise((resolve) => {
+        proc.on("close", (code) => {
+          resolve(code ?? 0);
+        });
+      });
+    }
+  };
+}
+
+// src/workspace/fuse.ts
+import { rmSync } from "fs";
+
+// src/fuse/mount.ts
+import { execSync } from "child_process";
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// src/fuse/fs.ts
+import { FileType } from "@struktoai/mirage-core";
+
+// src/fuse/platform/macos.ts
+var MACOS_METADATA = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  ".Spotlight-V100",
+  ".fseventsd",
+  ".Trashes"
+]);
+function isMacosMetadata(name) {
+  return MACOS_METADATA.has(name) || name.startsWith("._");
+}
+
+// src/fuse/fs.ts
+var ENV_AGENT_ID = "MIRAGE_AGENT_ID";
+var MIRAGE_DIR = "/.mirage";
+var MIRAGE_WHOAMI = "/.mirage/whoami";
+var ENOENT = -2;
+var EACCES = -13;
+var ENOTDIR = -20;
+var EEXIST = -17;
+var ENOTEMPTY = -66;
+var EIO = -5;
+var PREFETCH_TTL_MS = 3e4;
+var UNKNOWN_SIZE_SENTINEL = 100 * 1024 * 1024;
+function classifyError(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  if (msg.includes("not empty") || msg.includes("enotempty")) return ENOTEMPTY;
+  if (msg.includes("not a directory") || msg.includes("enotdir")) return ENOTDIR;
+  if (msg.includes("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;
+  agentId;
+  now;
+  prefixes;
+  handles = /* @__PURE__ */ new Map();
+  prefetchCache = /* @__PURE__ */ new Map();
+  prefetchInflight = /* @__PURE__ */ new Map();
+  nextFh = 1;
+  uid;
+  gid;
+  constructor(ws, options = {}) {
+    this.ws = ws;
+    this.agentId = options.agentId ?? process.env[ENV_AGENT_ID] ?? `agent-${Math.random().toString(36).slice(2, 10)}`;
+    this.now = /* @__PURE__ */ new Date();
+    this.prefixes = ws.mounts().map((m) => m.prefix);
+    this.uid = typeof process.getuid === "function" ? process.getuid() : 0;
+    this.gid = typeof process.getgid === "function" ? process.getgid() : 0;
+  }
+  // ── helpers ──────────────────────────────────────────────────────
+  whoamiContent() {
+    const lines = [`agent: ${this.agentId}`, "cwd: /", `mounts: ${this.prefixes.join(", ")}`];
+    return new TextEncoder().encode(lines.join("\n") + "\n");
+  }
+  dirStat() {
+    return {
+      mtime: this.now,
+      atime: this.now,
+      ctime: this.now,
+      nlink: 2,
+      size: 0,
+      mode: 16877,
+      uid: this.uid,
+      gid: this.gid
+    };
+  }
+  fileStat(size) {
+    return {
+      mtime: this.now,
+      atime: this.now,
+      ctime: this.now,
+      nlink: 1,
+      size,
+      mode: 33188,
+      uid: this.uid,
+      gid: this.gid
+    };
+  }
+  isVirtualDir(path) {
+    const bare = path.replace(/\/+$/, "");
+    const normalized = bare + "/";
+    for (const p of this.prefixes) {
+      const pBare = p.replace(/\/+$/, "");
+      if (p.startsWith(normalized) || pBare === bare) return true;
+    }
+    return false;
+  }
+  virtualChildren(path) {
+    const normalized = path === "/" ? "/" : path.replace(/\/+$/, "") + "/";
+    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(path) {
+    for (const ctx of this.handles.values()) {
+      if (ctx.path === path && ctx.data !== void 0) return ctx.data.byteLength;
+    }
+    const entry = this.prefetchCache.get(path);
+    if (entry !== void 0 && entry.expires > Date.now()) return entry.data.byteLength;
+    return null;
+  }
+  cachedData(path) {
+    for (const ctx of this.handles.values()) {
+      if (ctx.path === path && ctx.data !== void 0) return ctx.data;
+    }
+    const entry = this.prefetchCache.get(path);
+    if (entry !== void 0 && entry.expires > Date.now()) return entry.data;
+    if (entry !== void 0) this.prefetchCache.delete(path);
+    return null;
+  }
+  /**
+   * Fetch bytes for a size-unknown file and cache them so the immediate
+   * getattr → open → read burst (and subsequent stats within the TTL) reuse
+   * the same fetch. Required because @zkochan/fuse-native doesn't expose
+   * libfuse's `direct_io` flag — without a real size from getattr, the kernel
+   * decides the file is empty and never issues read().
+   */
+  async prefetch(path) {
+    const cached = this.cachedData(path);
+    if (cached !== null) return cached;
+    const inflight = this.prefetchInflight.get(path);
+    if (inflight !== void 0) return inflight;
+    const promise = (async () => {
+      try {
+        const data = await this.ws.fs.readFile(path);
+        this.prefetchCache.set(path, { data, expires: Date.now() + PREFETCH_TTL_MS });
+        return data;
+      } catch {
+        return null;
+      } finally {
+        this.prefetchInflight.delete(path);
+      }
+    })();
+    this.prefetchInflight.set(path, promise);
+    return promise;
+  }
+  /** Drain and return accumulated op records (mirrors Python's drain_ops). */
+  drainOps() {
+    const records = [...this.ws.records];
+    this.ws.records.length = 0;
+    return records;
+  }
+  // ── FUSE op surface (mirrors mfusepy Operations) ─────────────────
+  ops() {
+    return {
+      readdir: this.readdir.bind(this),
+      getattr: this.getattr.bind(this),
+      open: this.open.bind(this),
+      read: this.read.bind(this),
+      write: this.write.bind(this),
+      create: this.create.bind(this),
+      unlink: this.unlink.bind(this),
+      mkdir: this.mkdir.bind(this),
+      rmdir: this.rmdir.bind(this),
+      rename: this.rename.bind(this),
+      release: this.release.bind(this),
+      truncate: this.truncate.bind(this),
+      flush: this.flush.bind(this),
+      fsync: this.fsync.bind(this),
+      utimens: this.utimens.bind(this),
+      chmod: this.chmod.bind(this),
+      chown: this.chown.bind(this),
+      access: this.access.bind(this),
+      statfs: this.statfs.bind(this)
+    };
+  }
+  getattr(path, cb) {
+    void (async () => {
+      if (path === "/" || path === MIRAGE_DIR) {
+        cb(0, this.dirStat());
+        return;
+      }
+      if (path === MIRAGE_WHOAMI) {
+        cb(0, this.fileStat(this.whoamiContent().byteLength));
+        return;
+      }
+      const name = path.slice(path.lastIndexOf("/") + 1);
+      if (isMacosMetadata(name)) {
+        cb(ENOENT);
+        return;
+      }
+      if (this.isVirtualDir(path)) {
+        cb(0, this.dirStat());
+        return;
+      }
+      try {
+        const s = await this.ws.fs.stat(path);
+        if (s.type === FileType.DIRECTORY) {
+          cb(0, this.dirStat());
+          return;
+        }
+        let size = s.size;
+        size ??= this.cachedSize(path) ?? UNKNOWN_SIZE_SENTINEL;
+        cb(0, this.fileStat(size));
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  readdir(path, cb) {
+    void (async () => {
+      if (path === MIRAGE_DIR) {
+        cb(0, [".", "..", "whoami"]);
+        return;
+      }
+      const names = new Set(this.virtualChildren(path));
+      if (path === "/") names.add(".mirage");
+      try {
+        const entries = await this.ws.fs.readdir(path);
+        for (const e of entries) {
+          const part = e.replace(/\/+$/, "").split("/").pop() ?? "";
+          if (part !== "" && !isMacosMetadata(part)) names.add(part);
+        }
+      } catch {
+        if (names.size === 0) {
+          cb(ENOENT);
+          return;
+        }
+      }
+      cb(0, [".", "..", ...[...names].sort()]);
+    })();
+  }
+  read(path, fd, buf, len, pos, cb) {
+    void (async () => {
+      if (path === MIRAGE_WHOAMI) {
+        const data = this.whoamiContent();
+        const slice = data.subarray(pos, pos + len);
+        buf.set(slice, 0);
+        cb(slice.byteLength);
+        return;
+      }
+      const ctx = this.handles.get(fd);
+      try {
+        if (ctx !== void 0 && ctx.data === void 0) {
+          const cached = this.cachedData(path);
+          ctx.data = cached ?? await this.ws.fs.readFile(path);
+        }
+        const data = ctx?.data ?? this.cachedData(path) ?? await this.ws.fs.readFile(path);
+        const slice = data.subarray(pos, pos + len);
+        buf.set(slice, 0);
+        cb(slice.byteLength);
+      } catch {
+        cb(0);
+      }
+    })();
+  }
+  write(path, 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(path, { 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.ws.fs.writeFile(path, merged);
+        cb(len);
+      } catch {
+        cb(0);
+      }
+    })();
+  }
+  create(path, _mode, cb) {
+    void (async () => {
+      try {
+        try {
+          await this.ws.dispatch("create", path);
+        } catch (dispatchErr) {
+          const msg = (dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr)).toLowerCase();
+          if (!msg.includes("no op")) throw dispatchErr;
+          await this.ws.fs.writeFile(path, new Uint8Array(0));
+        }
+        const fh = this.nextFh++;
+        this.handles.set(fh, { path });
+        cb(0, fh);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  mkdir(path, _mode, cb) {
+    void (async () => {
+      try {
+        await this.ws.fs.mkdir(path);
+        cb(0);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  unlink(path, cb) {
+    void (async () => {
+      try {
+        await this.ws.fs.unlink(path);
+        cb(0);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  rename(src, dst, cb) {
+    void (async () => {
+      try {
+        await this.ws.fs.rename(src, dst);
+        cb(0);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  rmdir(path, cb) {
+    void (async () => {
+      try {
+        try {
+          const entries = await this.ws.fs.readdir(path);
+          if (entries.length > 0) {
+            cb(ENOTEMPTY);
+            return;
+          }
+        } catch {
+        }
+        await this.ws.fs.rmdir(path);
+        cb(0);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  truncate(path, size, cb) {
+    void (async () => {
+      try {
+        try {
+          await this.ws.dispatch("truncate", path, [size]);
+        } catch (dispatchErr) {
+          const msg = (dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr)).toLowerCase();
+          if (!msg.includes("no op")) throw dispatchErr;
+          const data = await this.ws.fs.readFile(path, { raw: true }).catch(() => new Uint8Array(0));
+          const out = new Uint8Array(size);
+          out.set(data.subarray(0, Math.min(data.byteLength, size)), 0);
+          await this.ws.fs.writeFile(path, out);
+        }
+        cb(0);
+      } catch (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
+    });
+  }
+  // chmod / chown / utimens / access are no-ops for the filesystem but must
+  // validate path existence — callers like `touch`/`chmod` on a missing file
+  // should fail with ENOENT, not silently succeed.
+  chmod(path, _mode, cb) {
+    this.getattrValidate(path, cb);
+  }
+  chown(path, _uid, _gid, cb) {
+    this.getattrValidate(path, cb);
+  }
+  utimens(path, _atime, _mtime, cb) {
+    this.getattrValidate(path, cb);
+  }
+  access(path, _amode, cb) {
+    this.getattrValidate(path, cb);
+  }
+  getattrValidate(path, cb) {
+    this.getattr(path, (code) => {
+      cb(code);
+    });
+  }
+  open(path, _flags, cb) {
+    void (async () => {
+      if (path === MIRAGE_WHOAMI) {
+        const fh = this.nextFh++;
+        this.handles.set(fh, { path });
+        cb(0, fh);
+        return;
+      }
+      try {
+        const s = await this.ws.fs.stat(path);
+        const ctx = { path };
+        if (s.size === null && s.type !== FileType.DIRECTORY) {
+          const data = await this.prefetch(path);
+          if (data !== null) ctx.data = data;
+        }
+        const fh = this.nextFh++;
+        this.handles.set(fh, ctx);
+        cb(0, fh);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  release(_path, fd, cb) {
+    this.handles.delete(fd);
+    cb(0);
+  }
+  flush(path, 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(path, { 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.ws.fs.writeFile(path, merged);
+        cb(0);
+      } catch (err) {
+        cb(classifyError(err));
+      }
+    })();
+  }
+  fsync(path, _datasync, fd, cb) {
+    this.flush(path, fd, cb);
+  }
+};
+
+// src/fuse/mount.ts
+async function loadFuse() {
+  const mod = await loadOptionalPeer(
+    () => import("@zkochan/fuse-native"),
+    {
+      feature: "FUSE support",
+      packageName: "@zkochan/fuse-native",
+      docsUrl: "https://mirage.dev/typescript/setup/fuse"
+    }
+  );
+  const Fuse = mod.default ?? mod;
+  if (typeof Fuse !== "function") {
+    throw new Error("@zkochan/fuse-native did not export a constructor");
+  }
+  return Fuse;
+}
+function forceUnmount(mountpoint) {
+  try {
+    if (process.platform === "darwin") {
+      execSync(`diskutil unmount force ${JSON.stringify(mountpoint)}`, { stdio: "ignore" });
+    } else {
+      execSync(`fusermount -u ${JSON.stringify(mountpoint)}`, { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
+async function mount(ws, options = {}) {
+  const Fuse = await loadFuse();
+  const mountpoint = options.mountpoint ?? mkdtempSync(join(tmpdir(), "mirage-fuse-"));
+  const agentId = options.agentId;
+  const mfs = new MirageFS(ws, agentId !== void 0 ? { agentId } : {});
+  const autoUnmount = options.autoUnmount ?? process.platform === "linux";
+  const fuseOpts = {
+    force: true,
+    mkdir: true,
+    ...autoUnmount ? { autoUnmount: true } : {},
+    ...options.fuseOptions ?? {}
+  };
+  const fuse = new Fuse(mountpoint, mfs.ops(), fuseOpts);
+  await new Promise((resolve, reject) => {
+    fuse.mount((err) => {
+      if (err === null) resolve();
+      else reject(err);
+    });
+  });
+  return {
+    mountpoint,
+    unmount: () => new Promise((resolve, reject) => {
+      fuse.unmount((err) => {
+        if (err === null) resolve();
+        else reject(err);
+      });
+    })
+  };
+}
+function mountBackground(ws, options = {}) {
+  return mount(ws, options);
+}
+
+// src/workspace/fuse.ts
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var FuseCleanupRegistry = class {
+  mounts = /* @__PURE__ */ new Set();
+  installed = false;
+  exiting = false;
+  register(entry) {
+    this.mounts.add(entry);
+    this.install();
+  }
+  unregister(entry) {
+    this.mounts.delete(entry);
+  }
+  install() {
+    if (this.installed) return;
+    this.installed = true;
+    for (const sig of SIGNALS) {
+      process.on(sig, this.onSignal);
+    }
+    process.on("beforeExit", this.onExit);
+    process.on("exit", this.onExit);
+  }
+  onSignal = (sig) => {
+    if (this.exiting) return;
+    this.exiting = true;
+    this.drainSync();
+    process.kill(process.pid, sig);
+  };
+  onExit = () => {
+    if (this.exiting) return;
+    this.exiting = true;
+    this.drainSync();
+  };
+  drainSync() {
+    for (const entry of this.mounts) {
+      forceUnmount(entry.mountpoint);
+      try {
+        rmSync(entry.mountpoint, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    this.mounts.clear();
+  }
+};
+var CLEANUP = new FuseCleanupRegistry();
+var FuseManager = class {
+  handle = null;
+  externalMountpoint = null;
+  auto = false;
+  cleanupEntry = null;
+  get mountpoint() {
+    if (this.handle !== null) return this.handle.mountpoint;
+    return this.externalMountpoint;
+  }
+  set mountpoint(path) {
+    this.externalMountpoint = path;
+  }
+  async setup(ws, options = {}) {
+    if (this.handle !== null) return this.handle.mountpoint;
+    this.handle = await mount(ws, options);
+    this.auto = true;
+    this.externalMountpoint = null;
+    this.cleanupEntry = { mountpoint: this.handle.mountpoint, handle: this.handle };
+    CLEANUP.register(this.cleanupEntry);
+    ws.setFuseMountpoint(this.handle.mountpoint, { owned: true });
+    return this.handle.mountpoint;
+  }
+  async unmount(ws) {
+    if (this.handle === null) {
+      if (ws !== void 0) ws.setFuseMountpoint(null);
+      this.externalMountpoint = null;
+      return;
+    }
+    const mp = this.handle.mountpoint;
+    try {
+      await this.handle.unmount();
+    } finally {
+      if (this.cleanupEntry !== null) {
+        CLEANUP.unregister(this.cleanupEntry);
+        this.cleanupEntry = null;
+      }
+      this.handle = null;
+      this.auto = false;
+      ws?.setFuseMountpoint(null);
+      try {
+        rmSync(mp, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  async close(ws) {
+    if (this.auto) await this.unmount(ws);
+  }
+};
+
+// src/workspace.ts
+var requireCjs = createRequire(import.meta.url);
+var cachedParser = null;
+function loadShellParser() {
+  if (cachedParser !== null) return cachedParser;
+  const enginePath = requireCjs.resolve("web-tree-sitter/web-tree-sitter.wasm");
+  const grammarPath = requireCjs.resolve("tree-sitter-bash/tree-sitter-bash.wasm");
+  cachedParser = createShellParser({
+    engineWasm: readFileSync(enginePath),
+    grammarWasm: readFileSync(grammarPath)
+  });
+  return cachedParser;
+}
+var Workspace = class extends CoreWorkspace {
+  defaultNative;
+  autoFuseManager;
+  fuseSetupPromise = null;
+  constructor(resources, options = {}) {
+    super(resources, {
+      ...options,
+      shellParserFactory: options.shellParserFactory ?? loadShellParser
+    });
+    this.defaultNative = options.native ?? false;
+    this.autoFuseManager = options.fuse === true ? new FuseManager() : null;
+    if (this.autoFuseManager !== null) {
+      const fm = this.autoFuseManager;
+      this.fuseSetupPromise = fm.setup(this).then(() => void 0);
+    }
+  }
+  async ensureFuseReady() {
+    if (this.fuseSetupPromise !== null) {
+      await this.fuseSetupPromise;
+      this.fuseSetupPromise = null;
+    }
+  }
+  async execute(command31, options = {}) {
+    await this.ensureFuseReady();
+    const useNative = options.native ?? this.defaultNative;
+    if (useNative) {
+      const mp = this.fuseMountpoint;
+      if (mp === null) {
+        console.warn(
+          "native=true requires FUSE. Install macFUSE (macOS) or libfuse (Linux) and set ws.setFuseMountpoint(). Falling back to virtual mode."
+        );
+      } else if (this.ownsFuseMount) {
+        throw new Error(
+          "native=true with a same-process FUSE mount would deadlock (Node single event loop). Workarounds:\n  1. Mount FUSE in a helper process; call nativeExec from this process.\n  2. Point nativeExec at a mountpoint created by another tool (then call ws.setFuseMountpoint(path) without using FuseManager).\n  3. Use execute() without native=true (virtual executor is in-process safe).\nSee https://mirage.dev/typescript/limitations for details."
+        );
+      } else {
+        const opts = { cwd: mp };
+        if (options.signal !== void 0) opts.signal = options.signal;
+        const { stdout, stderr, exitCode } = await nativeExec(command31, opts);
+        return new ExecuteResult2(stdout, stderr, exitCode);
+      }
+    }
+    return super.execute(command31, options);
+  }
+  async close() {
+    await this.ensureFuseReady().catch(() => void 0);
+    if (this.autoFuseManager !== null) {
+      await this.autoFuseManager.close(this);
+    }
+    await super.close();
+  }
+};
+
+// src/fs_monkey.ts
+import { Buffer as Buffer2 } from "buffer";
+import { createRequire as createRequire2 } from "module";
+import { FileType as FileType2 } from "@struktoai/mirage-core";
+var requireCjs2 = createRequire2(import.meta.url);
+var fs = requireCjs2("node:fs");
+var fsMonkey = requireCjs2("fs-monkey");
+var { patchFs } = fsMonkey;
+function mountedPath(ws, p) {
+  try {
+    return ws.registry.mountFor(p) !== null;
+  } catch {
+    return false;
+  }
+}
+async function mirageStat(ws, p) {
+  const s = await ws.fs.stat(p);
+  const isDir = s.type === FileType2.DIRECTORY;
+  const mtime = s.modified !== null ? new Date(s.modified) : /* @__PURE__ */ new Date(0);
+  return {
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    size: s.size ?? 0,
+    mtime,
+    mtimeMs: mtime.getTime(),
+    atime: mtime,
+    atimeMs: mtime.getTime(),
+    ctime: mtime,
+    ctimeMs: mtime.getTime(),
+    birthtime: mtime,
+    birthtimeMs: mtime.getTime(),
+    mode: 0,
+    nlink: 1,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    blksize: 0,
+    blocks: 0,
+    dev: 0,
+    ino: 0
+  };
+}
+function patchNodeFs(ws) {
+  const originalFs = { ...fs };
+  const vol = {
+    promises: {
+      readFile: async (p, opts) => {
+        if (mountedPath(ws, p)) {
+          const bytes = await ws.fs.readFile(p);
+          const encoding = typeof opts === "string" ? opts : opts?.encoding;
+          if (encoding !== void 0) return Buffer2.from(bytes).toString(encoding);
+          return Buffer2.from(bytes);
+        }
+        const native = originalFs.promises.readFile;
+        return native(p, opts);
+      },
+      writeFile: async (p, data) => {
+        if (mountedPath(ws, p)) {
+          await ws.fs.writeFile(p, typeof data === "string" ? data : data);
+          return;
+        }
+        const native = originalFs.promises.writeFile;
+        await native(p, data);
+      },
+      readdir: async (p) => {
+        if (mountedPath(ws, p)) {
+          const entries = await ws.fs.readdir(p);
+          return entries.map((e) => {
+            const trimmed = e.endsWith("/") ? e.slice(0, -1) : e;
+            return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+          });
+        }
+        const native = originalFs.promises.readdir;
+        return native(p);
+      },
+      stat: async (p) => {
+        if (mountedPath(ws, p)) return mirageStat(ws, p);
+        const native = originalFs.promises.stat;
+        return native(p);
+      },
+      unlink: async (p) => {
+        if (mountedPath(ws, p)) return ws.fs.unlink(p);
+        const native = originalFs.promises.unlink;
+        await native(p);
+      },
+      mkdir: async (p) => {
+        if (mountedPath(ws, p)) return ws.fs.mkdir(p);
+        const native = originalFs.promises.mkdir;
+        await native(p);
+      },
+      rmdir: async (p) => {
+        if (mountedPath(ws, p)) return ws.fs.rmdir(p);
+        const native = originalFs.promises.rmdir;
+        await native(p);
+      }
+    },
+    readFileSync: () => {
+      throw new Error("mirage.patchNodeFs: sync fs methods not supported \u2014 use fs.promises.*");
+    },
+    readFile: (p, cb) => {
+      if (mountedPath(ws, p)) {
+        ws.fs.readFile(p).then((data) => {
+          cb(null, Buffer2.from(data));
+        }).catch((err) => {
+          cb(err);
+        });
+        return;
+      }
+      const native = originalFs.readFile;
+      native(p, cb);
+    },
+    readdir: (p, cb) => {
+      if (mountedPath(ws, p)) {
+        ws.fs.readdir(p).then((entries) => {
+          cb(
+            null,
+            entries.map((e) => {
+              const trimmed = e.endsWith("/") ? e.slice(0, -1) : e;
+              return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+            })
+          );
+        }).catch((err) => {
+          cb(err);
+        });
+        return;
+      }
+      const native = originalFs.readdir;
+      native(p, cb);
+    }
+  };
+  patchFs(vol, fs);
+  return function restore() {
+    for (const [k, v] of Object.entries(originalFs)) {
+      const desc = Object.getOwnPropertyDescriptor(fs, k);
+      if (desc?.writable === false && desc.set === void 0) continue;
+      try {
+        fs[k] = v;
+      } catch {
+      }
+    }
+  };
+}
+
+// src/commands/builtin/redis/provision.ts
+import {
+  Precision,
+  ProvisionResult
+} from "@struktoai/mirage-core";
+async function resolveSizes(accessor, paths, index) {
+  const resolved = [];
+  let missing = 0;
+  for (const p of paths) {
+    const pathStr = p.original;
+    let size = null;
+    if (index !== void 0) {
+      const lookup = await index.get(pathStr);
+      if (lookup.entry !== void 0 && lookup.entry !== null) {
+        size = lookup.entry.size;
+      }
+    }
+    if (size === null) {
+      try {
+        const fileStat = await stat2(accessor, p);
+        size = fileStat.size;
+      } catch {
+      }
+    }
+    if (size !== null) {
+      resolved.push([pathStr, size]);
+    } else {
+      missing += 1;
+    }
+  }
+  return { resolved, missing };
+}
+async function fileReadProvision(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return new ProvisionResult({ precision: Precision.UNKNOWN });
+  }
+  const { resolved, missing } = await resolveSizes(accessor, paths, void 0);
+  if (missing > 0 || resolved.length === 0) {
+    return new ProvisionResult({ precision: Precision.UNKNOWN });
+  }
+  const total = resolved.reduce((sum, [, size]) => sum + size, 0);
+  return new ProvisionResult({
+    networkReadLow: total,
+    networkReadHigh: total,
+    readOps: resolved.length,
+    precision: Precision.EXACT
+  });
+}
+async function headTailProvision(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return new ProvisionResult({ precision: Precision.UNKNOWN });
+  }
+  const { resolved, missing } = await resolveSizes(accessor, paths, void 0);
+  if (missing > 0 || resolved.length === 0) {
+    return new ProvisionResult({ precision: Precision.UNKNOWN });
+  }
+  const total = resolved.reduce((sum, [, size]) => sum + size, 0);
+  return new ProvisionResult({
+    networkReadLow: total,
+    networkReadHigh: total,
+    readOps: resolved.length,
+    precision: Precision.EXACT
+  });
+}
+function metadataProvision(_accessor, paths, _texts, _opts) {
+  const n = Math.max(1, paths.length > 0 ? paths.length : 1);
+  return new ProvisionResult({
+    networkReadLow: 0,
+    networkReadHigh: 0,
+    readOps: n,
+    precision: Precision.EXACT
+  });
+}
+
+// src/cache/redis/file.ts
+import {
+  defaultFingerprint,
+  parseLimit
+} from "@struktoai/mirage-core";
+var RedisFileCacheStore = class extends RedisResource {
+  limit;
+  dataPrefix;
+  metaPrefix;
+  maxDrainBytes;
+  constructor(options = {}) {
+    super({
+      url: options.url ?? "redis://localhost:6379/0",
+      keyPrefix: options.keyPrefix ?? "mirage:cache:"
+    });
+    this.limit = parseLimit(options.cacheLimit ?? "512MB");
+    this.dataPrefix = `${this.keyPrefix}data:`;
+    this.metaPrefix = `${this.keyPrefix}meta:`;
+    this.maxDrainBytes = options.maxDrainBytes ?? null;
+  }
+  cacheSize = 0;
+  get cacheLimit() {
+    return this.limit;
+  }
+  cacheClient() {
+    return this.store.client();
+  }
+  async get(key) {
+    const c = await this.cacheClient();
+    const mod = await this.module();
+    const blob = mod.RESP_TYPES.BLOB_STRING;
+    const mapping = { [blob]: Buffer };
+    const typed = c;
+    const raw = await typed.withTypeMapping(mapping).get(`${this.dataPrefix}${key}`);
+    if (raw === null) return null;
+    return new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+  }
+  async set(key, data, options = {}) {
+    const fp = options.fingerprint ?? defaultFingerprint(data);
+    const c = await this.cacheClient();
+    const dk = `${this.dataPrefix}${key}`;
+    const mk = `${this.metaPrefix}${key}`;
+    const pipe = c.multi();
+    pipe.set(dk, Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+    pipe.set(mk, fp);
+    if (options.ttl !== null && options.ttl !== void 0) {
+      pipe.expire(dk, options.ttl);
+      pipe.expire(mk, options.ttl);
+    }
+    await pipe.exec();
+  }
+  async add(key, data, options = {}) {
+    const c = await this.cacheClient();
+    const exists = await c.exists(`${this.dataPrefix}${key}`);
+    if (exists) return false;
+    await this.set(key, data, options);
+    return true;
+  }
+  async remove(key) {
+    const c = await this.cacheClient();
+    const pipe = c.multi();
+    pipe.del(`${this.dataPrefix}${key}`);
+    pipe.del(`${this.metaPrefix}${key}`);
+    await pipe.exec();
+  }
+  async exists(key) {
+    const k = typeof key === "string" ? key : key.stripPrefix;
+    const c = await this.cacheClient();
+    return await c.exists(`${this.dataPrefix}${k}`) > 0;
+  }
+  async isFresh(key, remoteFingerprint) {
+    const c = await this.cacheClient();
+    const fp = await c.get(`${this.metaPrefix}${key}`);
+    if (fp === null) return false;
+    return fp === remoteFingerprint;
+  }
+  async clear() {
+    const c = await this.cacheClient();
+    for (const pattern of [`${this.dataPrefix}*`, `${this.metaPrefix}*`]) {
+      const batch = [];
+      for await (const k of c.scanIterator({ MATCH: pattern })) {
+        if (Array.isArray(k)) batch.push(...k);
+        else batch.push(k);
+      }
+      if (batch.length > 0) await c.del(batch);
+    }
+  }
+  async allCached(keys) {
+    for (const k of keys) {
+      if (!await this.exists(k)) return false;
+    }
+    return true;
+  }
+  async multiGet(keys) {
+    const out = [];
+    for (const k of keys) out.push(await this.get(k));
+    return out;
+  }
+};
+
+// src/cache/redis/index_cache.ts
+import {
+  IndexCacheStore,
+  IndexEntry,
+  LookupStatus
+} from "@struktoai/mirage-core";
+var ENTRY_PREFIX = "mirage:idx:entry:";
+var CHILDREN_PREFIX = "mirage:idx:children:";
+var RedisIndexCacheStore = class _RedisIndexCacheStore extends IndexCacheStore {
+  ttl;
+  url;
+  providedClient;
+  entryPrefix;
+  childrenPrefix;
+  clientPromise = null;
+  constructor(options = {}) {
+    super();
+    this.ttl = options.ttl ?? 600;
+    this.url = options.url ?? "redis://localhost:6379/0";
+    this.providedClient = options.client ?? null;
+    const prefix = options.keyPrefix ?? "";
+    this.entryPrefix = `${prefix}${ENTRY_PREFIX}`;
+    this.childrenPrefix = `${prefix}${CHILDREN_PREFIX}`;
+  }
+  static fromConfig(config, extra = {}) {
+    return new _RedisIndexCacheStore({ ttl: config.ttl ?? 600, ...extra });
+  }
+  entryKey(path) {
+    return `${this.entryPrefix}${path}`;
+  }
+  childrenKey(path) {
+    return `${this.childrenPrefix}${path}`;
+  }
+  client() {
+    if (this.providedClient !== null) return Promise.resolve(this.providedClient);
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("redis"),
+        { feature: "RedisIndexCacheStore", packageName: "redis" }
+      );
+      const c = mod.createClient({
+        url: this.url,
+        socket: { reconnectStrategy: false }
+      });
+      await c.connect();
+      return c;
+    })();
+    return this.clientPromise;
+  }
+  async get(resourcePath) {
+    const c = await this.client();
+    const raw = await c.get(this.entryKey(resourcePath));
+    if (raw === null) return { status: LookupStatus.NOT_FOUND };
+    const parsed = JSON.parse(raw);
+    return { entry: new IndexEntry(parsed) };
+  }
+  async put(resourcePath, entry) {
+    const c = await this.client();
+    const stored = entry.indexTime === "" ? entry.copyWith({ indexTime: (/* @__PURE__ */ new Date()).toISOString() }) : entry;
+    await c.set(this.entryKey(resourcePath), JSON.stringify(this.serialize(stored)));
+  }
+  async listDir(resourcePath) {
+    const c = await this.client();
+    const key = this.childrenKey(resourcePath);
+    const exists = await c.exists(key);
+    if (!exists) return { status: LookupStatus.NOT_FOUND };
+    const ttlRemaining = await c.ttl(key);
+    if (ttlRemaining === -2) return { status: LookupStatus.EXPIRED };
+    const raw = await c.lRange(key, 0, -1);
+    return { entries: [...raw].sort() };
+  }
+  async setDir(resourcePath, entries, expiredAt) {
+    const c = await this.client();
+    const now = /* @__PURE__ */ new Date();
+    const nowIso = now.toISOString();
+    const prefix = resourcePath === "/" ? "/" : `${resourcePath}/`;
+    const pipe = c.multi();
+    const childKeys = [];
+    for (const [name, entry] of entries) {
+      const fullPath = prefix + name;
+      const stored = entry.indexTime === "" ? entry.copyWith({ indexTime: nowIso }) : entry;
+      pipe.set(this.entryKey(fullPath), JSON.stringify(this.serialize(stored)));
+      childKeys.push(fullPath);
+    }
+    const childrenKey = this.childrenKey(resourcePath);
+    pipe.del(childrenKey);
+    if (childKeys.length > 0) {
+      childKeys.sort();
+      pipe.rPush(childrenKey, childKeys);
+    }
+    const ttlSeconds = expiredAt !== null && expiredAt !== void 0 ? Math.max(1, Math.floor((expiredAt.getTime() - now.getTime()) / 1e3)) : Math.max(1, Math.floor(this.ttl));
+    pipe.expire(childrenKey, ttlSeconds);
+    await pipe.exec();
+  }
+  async invalidateDir(resourcePath) {
+    const c = await this.client();
+    await c.del(this.childrenKey(resourcePath));
+  }
+  async clear() {
+    const c = await this.client();
+    for (const pattern of [`${this.entryPrefix}*`, `${this.childrenPrefix}*`]) {
+      const keys = [];
+      for await (const k of c.scanIterator({ MATCH: pattern })) {
+        if (Array.isArray(k)) keys.push(...k);
+        else keys.push(k);
+      }
+      if (keys.length > 0) await c.del(keys);
+    }
+  }
+  async close() {
+    if (this.providedClient !== null) return;
+    if (this.clientPromise === null) return;
+    const c = await this.clientPromise;
+    const typed = c;
+    if (typeof typed.destroy === "function") typed.destroy();
+    else if (c.isOpen) await c.quit();
+    this.clientPromise = null;
+  }
+  serialize(e) {
+    return {
+      id: e.id,
+      name: e.name,
+      resourceType: e.resourceType,
+      remoteTime: e.remoteTime,
+      indexTime: e.indexTime,
+      vfsName: e.vfsName,
+      size: e.size
+    };
+  }
+};
+
+// src/resource/sscholar/sscholar.ts
+import {
+  HttpSSCholarDriver,
+  PathSpec,
+  RAMIndexCacheStore,
+  ResourceName,
+  SSCHOLAR_PAPER_COMMANDS,
+  SSCHOLAR_PAPER_OPS,
+  SSCHOLAR_PAPER_PROMPT,
+  SSCholarAccessor,
+  resolveSSCholarConfig,
+  resolveSSCholarPaperGlob,
+  sscholarPaperRead,
+  sscholarPaperReaddir,
+  sscholarPaperStat
+} from "@struktoai/mirage-core";
+var SSCholarPaperResource = class {
+  kind = ResourceName.SSCHOLAR_PAPER;
+  isRemote = true;
+  indexTtl = 0;
+  prompt;
+  config;
+  driver;
+  accessor;
+  index;
+  constructor(options = {}) {
+    const opts = "config" in options || "driver" in options || "prefix" in options ? options : { config: options };
+    this.config = resolveSSCholarConfig(opts.config ?? {});
+    this.driver = opts.driver ?? new HttpSSCholarDriver({ baseUrl: this.config.baseUrl, apiKey: this.config.apiKey });
+    this.accessor = new SSCholarAccessor(this.driver, this.config);
+    this.index = new RAMIndexCacheStore({ ttl: this.indexTtl });
+    this.prompt = SSCHOLAR_PAPER_PROMPT.replace("{prefix}", opts.prefix ?? "");
+  }
+  open() {
+    return Promise.resolve();
+  }
+  async close() {
+    await this.driver.close();
+  }
+  ops() {
+    return SSCHOLAR_PAPER_OPS;
+  }
+  commands() {
+    return SSCHOLAR_PAPER_COMMANDS;
+  }
+  readFile(p) {
+    return sscholarPaperRead(this.accessor, p, this.index);
+  }
+  readdir(p) {
+    return sscholarPaperReaddir(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return sscholarPaperStat(this.accessor, p, this.index);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix !== "" ? paths.map(
+      (p) => p.prefix !== "" ? p : new PathSpec({
+        original: p.original,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        prefix
+      })
+    ) : paths;
+    return resolveSSCholarPaperGlob(this.accessor, effective, this.index);
+  }
+};
+
+// src/resource/sscholar/author.ts
+import {
+  HttpSSCholarDriver as HttpSSCholarDriver2,
+  PathSpec as PathSpec2,
+  RAMIndexCacheStore as RAMIndexCacheStore2,
+  ResourceName as ResourceName2,
+  SSCHOLAR_AUTHOR_COMMANDS,
+  SSCHOLAR_AUTHOR_OPS,
+  SSCHOLAR_AUTHOR_PROMPT,
+  SSCholarAccessor as SSCholarAccessor2,
+  resolveSSCholarAuthorGlob,
+  resolveSSCholarConfig as resolveSSCholarConfig2,
+  sscholarAuthorRead,
+  sscholarAuthorReaddir,
+  sscholarAuthorStat
+} from "@struktoai/mirage-core";
+var SSCholarAuthorResource = class {
+  kind = ResourceName2.SSCHOLAR_AUTHOR;
+  isRemote = true;
+  indexTtl = 0;
+  prompt;
+  config;
+  driver;
+  accessor;
+  index;
+  constructor(options = {}) {
+    const opts = "config" in options || "driver" in options || "prefix" in options ? options : { config: options };
+    this.config = resolveSSCholarConfig2(opts.config ?? {});
+    this.driver = opts.driver ?? new HttpSSCholarDriver2({ baseUrl: this.config.baseUrl, apiKey: this.config.apiKey });
+    this.accessor = new SSCholarAccessor2(this.driver, this.config);
+    this.index = new RAMIndexCacheStore2({ ttl: this.indexTtl });
+    this.prompt = SSCHOLAR_AUTHOR_PROMPT.replace("{prefix}", opts.prefix ?? "");
+  }
+  open() {
+    return Promise.resolve();
+  }
+  async close() {
+    await this.driver.close();
+  }
+  ops() {
+    return SSCHOLAR_AUTHOR_OPS;
+  }
+  commands() {
+    return SSCHOLAR_AUTHOR_COMMANDS;
+  }
+  readFile(p) {
+    return sscholarAuthorRead(this.accessor, p, this.index);
+  }
+  readdir(p) {
+    return sscholarAuthorReaddir(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return sscholarAuthorStat(this.accessor, p, this.index);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix !== "" ? paths.map(
+      (p) => p.prefix !== "" ? p : new PathSpec2({
+        original: p.original,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        prefix
+      })
+    ) : paths;
+    return resolveSSCholarAuthorGlob(this.accessor, effective, this.index);
+  }
+};
+
+// src/resource/vercel/vercel.ts
+import {
+  HttpVercelDriver,
+  PathSpec as PathSpec3,
+  RAMIndexCacheStore as RAMIndexCacheStore3,
+  ResourceName as ResourceName3,
+  VERCEL_COMMANDS,
+  VERCEL_OPS,
+  VERCEL_PROMPT,
+  VercelAccessor,
+  resolveVercelConfig,
+  resolveVercelGlob,
+  vercelRead,
+  vercelReaddir,
+  vercelStat
+} from "@struktoai/mirage-core";
+var VercelResource = class {
+  kind = ResourceName3.VERCEL;
+  isRemote = true;
+  indexTtl = 60;
+  prompt;
+  config;
+  driver;
+  accessor;
+  index;
+  constructor(options = {}) {
+    const opts = "config" in options || "driver" in options || "prefix" in options ? options : { config: options };
+    this.config = resolveVercelConfig(opts.config ?? {});
+    this.driver = opts.driver ?? new HttpVercelDriver({
+      baseUrl: this.config.baseUrl,
+      token: this.config.token,
+      teamId: this.config.teamId
+    });
+    this.accessor = new VercelAccessor(this.driver, this.config);
+    this.index = new RAMIndexCacheStore3({ ttl: this.indexTtl });
+    this.prompt = VERCEL_PROMPT.replace("{prefix}", opts.prefix ?? "");
+  }
+  open() {
+    return Promise.resolve();
+  }
+  async close() {
+    await this.driver.close();
+  }
+  ops() {
+    return VERCEL_OPS;
+  }
+  commands() {
+    return VERCEL_COMMANDS;
+  }
+  readFile(p) {
+    return vercelRead(this.accessor, p, this.index);
+  }
+  readdir(p) {
+    return vercelReaddir(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return vercelStat(this.accessor, p, this.index);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix !== "" ? paths.map(
+      (p) => p.prefix !== "" ? p : new PathSpec3({
+        original: p.original,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        prefix
+      })
+    ) : paths;
+    return resolveVercelGlob(this.accessor, effective, this.index);
+  }
+};
+
+// src/resource/posthog/posthog.ts
+import {
+  HttpPostHogDriver,
+  PathSpec as PathSpec4,
+  RAMIndexCacheStore as RAMIndexCacheStore4,
+  ResourceName as ResourceName4,
+  POSTHOG_COMMANDS,
+  POSTHOG_OPS,
+  POSTHOG_PROMPT,
+  PostHogAccessor,
+  posthogRead,
+  posthogReaddir,
+  posthogStat,
+  resolvePostHogConfig,
+  resolvePostHogGlob
+} from "@struktoai/mirage-core";
+var PostHogResource = class {
+  kind = ResourceName4.POSTHOG;
+  isRemote = true;
+  indexTtl = 60;
+  prompt;
+  config;
+  driver;
+  accessor;
+  index;
+  constructor(options = {}) {
+    const opts = "config" in options || "driver" in options || "prefix" in options ? options : { config: options };
+    this.config = resolvePostHogConfig(opts.config ?? {});
+    this.driver = opts.driver ?? new HttpPostHogDriver({ baseUrl: this.config.baseUrl, apiKey: this.config.apiKey });
+    this.accessor = new PostHogAccessor(this.driver, this.config);
+    this.index = new RAMIndexCacheStore4({ ttl: this.indexTtl });
+    this.prompt = POSTHOG_PROMPT.replace("{prefix}", opts.prefix ?? "");
+  }
+  open() {
+    return Promise.resolve();
+  }
+  async close() {
+    await this.driver.close();
+  }
+  ops() {
+    return POSTHOG_OPS;
+  }
+  commands() {
+    return POSTHOG_COMMANDS;
+  }
+  readFile(p) {
+    return posthogRead(this.accessor, p, this.index);
+  }
+  readdir(p) {
+    return posthogReaddir(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return posthogStat(this.accessor, p, this.index);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix !== "" ? paths.map(
+      (p) => p.prefix !== "" ? p : new PathSpec4({
+        original: p.original,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        prefix
+      })
+    ) : paths;
+    return resolvePostHogGlob(this.accessor, effective, this.index);
+  }
+};
+
+// src/resource/registry.ts
+import { normalizeFields } from "@struktoai/mirage-core";
+var REGISTRY = {
+  ram: async (_config2) => {
+    const { RAMResource } = await import("@struktoai/mirage-core");
+    return new RAMResource();
+  },
+  disk: async (config) => {
+    const { DiskResource: DiskResource2 } = await import("./disk-C7TJNU2B.js");
+    const norm2 = normalizeFields(config);
+    return new DiskResource2(norm2);
+  },
+  redis: async (config) => {
+    const { RedisResource: RedisResource2 } = await import("./redis-NVCXUUIO.js");
+    const norm2 = normalizeFields(config);
+    return new RedisResource2(norm2);
+  },
+  s3: async (config) => {
+    const { S3Resource: S3Resource2 } = await import("./s3-HVAL7ZX3.js");
+    const { normalizeS3Config } = await import("./config-ZZGIWDUC.js");
+    return new S3Resource2(normalizeS3Config(config));
+  },
+  gcs: async (config) => {
+    const { GCSResource: GCSResource2 } = await import("./gcs-P5QMKTPR.js");
+    const { normalizeGcsConfig } = await import("./config-HIZHA5VD.js");
+    return new GCSResource2(normalizeGcsConfig(config));
+  },
+  oci: async (config) => {
+    const { OCIResource: OCIResource2 } = await import("./oci-KZ7XFZ2X.js");
+    const { normalizeOciConfig } = await import("./config-UKZ72IDO.js");
+    return new OCIResource2(normalizeOciConfig(config));
+  },
+  r2: async (config) => {
+    const { R2Resource: R2Resource2 } = await import("./r2-X4DDNSAZ.js");
+    const { normalizeR2Config } = await import("./config-S47UDVRZ.js");
+    return new R2Resource2(normalizeR2Config(config));
+  },
+  supabase: async (config) => {
+    const { SupabaseResource: SupabaseResource2 } = await import("./supabase-H3ZP4Y3W.js");
+    const { normalizeSupabaseConfig } = await import("./config-5ZPGISS6.js");
+    return new SupabaseResource2(normalizeSupabaseConfig(config));
+  },
+  postgres: async (config) => {
+    const { PostgresResource: PostgresResource2 } = await import("./postgres-M2N2APFZ.js");
+    const { normalizePostgresConfig } = await import("@struktoai/mirage-core");
+    return new PostgresResource2(normalizePostgresConfig(config));
+  },
+  mongodb: async (config) => {
+    const { MongoDBResource: MongoDBResource2 } = await import("./mongodb-MK4DVSIK.js");
+    const { normalizeMongoDBConfig } = await import("@struktoai/mirage-core");
+    return new MongoDBResource2(normalizeMongoDBConfig(config));
+  },
+  slack: async (config) => {
+    const { SlackResource: SlackResource2 } = await import("./slack-GUQMDGLP.js");
+    const { normalizeSlackConfig: normalizeSlackConfig2 } = await import("./config-YLIX3ZBT.js");
+    return new SlackResource2(normalizeSlackConfig2(config));
+  },
+  ssh: async (config) => {
+    const { SSHResource: SSHResource2 } = await import("./ssh-LY6WYVVD.js");
+    const { normalizeSshConfig: normalizeSshConfig2 } = await import("./config-6TNFPYZF.js");
+    return new SSHResource2(normalizeSshConfig2(config));
+  },
+  discord: async (config) => {
+    const { DiscordResource: DiscordResource2 } = await import("./discord-2PWP2MGX.js");
+    const { normalizeDiscordConfig: normalizeDiscordConfig2 } = await import("./config-ZCZZAH5W.js");
+    return new DiscordResource2(normalizeDiscordConfig2(config));
+  },
+  trello: async (config) => {
+    const { TrelloResource: TrelloResource2 } = await import("./trello-WR6TEDYD.js");
+    const { normalizeTrelloConfig: normalizeTrelloConfig2 } = await import("./config-JXLZ4XEW.js");
+    return new TrelloResource2(normalizeTrelloConfig2(config));
+  },
+  linear: async (config) => {
+    const { LinearResource: LinearResource2 } = await import("./linear-WJDQ6JDE.js");
+    const { normalizeLinearConfig: normalizeLinearConfig2 } = await import("./config-Z5JGDOKE.js");
+    return new LinearResource2(normalizeLinearConfig2(config));
+  },
+  langfuse: async (config) => {
+    const { LangfuseResource: LangfuseResource2 } = await import("./langfuse-YKBYRQLU.js");
+    const { normalizeLangfuseConfig: normalizeLangfuseConfig2 } = await import("./config-MOLWOSRG.js");
+    return new LangfuseResource2(normalizeLangfuseConfig2(config));
+  },
+  github: async (config) => {
+    const { GitHubResource: GitHubResource2 } = await import("./github-5E6GSCNZ.js");
+    const { normalizeGitHubConfig: normalizeGitHubConfig2 } = await import("./config-V7XI5UTG.js");
+    return GitHubResource2.create(normalizeGitHubConfig2(config));
+  },
+  github_ci: async (config) => {
+    const { GitHubCIResource: GitHubCIResource2 } = await import("./github_ci-2DSZI3Y7.js");
+    const { normalizeGitHubCIConfig: normalizeGitHubCIConfig2 } = await import("./config-HNSDNQZH.js");
+    return new GitHubCIResource2(normalizeGitHubCIConfig2(config));
+  },
+  gdocs: async (config) => {
+    const { GDocsResource: GDocsResource2 } = await import("./gdocs-IF2I35HZ.js");
+    const { normalizeGDocsConfig: normalizeGDocsConfig2 } = await import("./config-IXLFUSMQ.js");
+    return new GDocsResource2(normalizeGDocsConfig2(config));
+  },
+  gsheets: async (config) => {
+    const { GSheetsResource: GSheetsResource2 } = await import("./gsheets-BAO54CQ7.js");
+    const { normalizeGSheetsConfig: normalizeGSheetsConfig2 } = await import("./config-KQCEMLNZ.js");
+    return new GSheetsResource2(normalizeGSheetsConfig2(config));
+  },
+  gslides: async (config) => {
+    const { GSlidesResource: GSlidesResource2 } = await import("./gslides-A62CEEMR.js");
+    const { normalizeGSlidesConfig: normalizeGSlidesConfig2 } = await import("./config-BHLXQ3OL.js");
+    return new GSlidesResource2(normalizeGSlidesConfig2(config));
+  },
+  gdrive: async (config) => {
+    const { GDriveResource: GDriveResource2 } = await import("./gdrive-TAETVCKP.js");
+    const { normalizeGDriveConfig: normalizeGDriveConfig2 } = await import("./config-E7UOEWEP.js");
+    return new GDriveResource2(normalizeGDriveConfig2(config));
+  },
+  dropbox: async (config) => {
+    const { DropboxResource: DropboxResource2 } = await import("./dropbox-L5DPYGKR.js");
+    const { normalizeDropboxConfig: normalizeDropboxConfig2 } = await import("./config-R3XJ5OW4.js");
+    return new DropboxResource2(normalizeDropboxConfig2(config));
+  },
+  box: async (config) => {
+    const { BoxResource: BoxResource2 } = await import("./box-4P7DCJH7.js");
+    const { normalizeBoxConfig: normalizeBoxConfig2 } = await import("./config-J3TM7NIS.js");
+    return new BoxResource2(normalizeBoxConfig2(config));
+  },
+  gmail: async (config) => {
+    const { GmailResource: GmailResource2 } = await import("./gmail-F5VYGKOT.js");
+    const { normalizeGmailConfig: normalizeGmailConfig2 } = await import("./config-6HWSKHEU.js");
+    return new GmailResource2(normalizeGmailConfig2(config));
+  },
+  email: async (config) => {
+    const { EmailResource: EmailResource2 } = await import("./email-HASRFBKC.js");
+    const { normalizeEmailConfig: normalizeEmailConfig2 } = await import("./config-FNR6LJ5H.js");
+    return new EmailResource2(normalizeEmailConfig2(config));
+  }
+};
+function knownResources() {
+  return Object.keys(REGISTRY).sort();
+}
+function register(name, factory) {
+  REGISTRY[name] = factory;
+}
+async function buildResource(name, config = {}) {
+  const factory = REGISTRY[name];
+  if (factory === void 0) {
+    throw new Error(
+      `unknown resource ${JSON.stringify(name)}; known: ${knownResources().join(", ")}`
+    );
+  }
+  return factory(config);
+}
+
+// src/commands/local_audio/disk/cat_mp3.ts
+import {
+  IOResult,
+  ResourceName as ResourceName5,
+  command,
+  materialize,
+  specOf
+} from "@struktoai/mirage-core";
+
+// src/commands/local_audio/utils.ts
+import { createRequire as createRequire3 } from "module";
+import { join as join2 } from "path";
+import { parseBuffer } from "music-metadata";
+var _config = {};
+var ENC = new TextEncoder();
+var DEC = new TextDecoder();
+var _sherpa = null;
+var _wavefile = null;
+var _recognizer = null;
+var _loadedModelDir = null;
+var require2 = createRequire3(import.meta.url);
+function loadSherpa() {
+  if (_sherpa !== null) return _sherpa;
+  try {
+    _sherpa = require2("sherpa-onnx-node");
+    return _sherpa;
+  } catch {
+    throw new Error(
+      "Audio transcription requires 'sherpa-onnx-node'. Install with: npm i sherpa-onnx-node  (or pnpm/yarn add)."
+    );
+  }
+}
+function loadWavefile() {
+  if (_wavefile !== null) return _wavefile;
+  try {
+    _wavefile = require2("wavefile");
+    return _wavefile;
+  } catch {
+    throw new Error(
+      "Built-in WAV decoding requires 'wavefile'. Install with: npm i wavefile  (or pass a custom recognizer via configure({ recognizer }) to skip it)."
+    );
+  }
+}
+function getRecognizer(modelDir) {
+  if (_recognizer !== null && _loadedModelDir === modelDir) return _recognizer;
+  const sherpa = loadSherpa();
+  _recognizer = new sherpa.OfflineRecognizer({
+    featConfig: { sampleRate: 16e3, featureDim: 80 },
+    modelConfig: {
+      whisper: {
+        encoder: join2(modelDir, "base-encoder.int8.onnx"),
+        decoder: join2(modelDir, "base-decoder.int8.onnx")
+      },
+      tokens: join2(modelDir, "base-tokens.txt"),
+      numThreads: 2,
+      provider: "cpu"
+    }
+  });
+  _loadedModelDir = modelDir;
+  return _recognizer;
+}
+function configure(opts) {
+  if (opts.modelDir !== void 0) _config.modelDir = opts.modelDir;
+  if (opts.recognizer !== void 0) _config.recognizer = opts.recognizer;
+  if (opts.modelDir !== void 0 && opts.modelDir !== _loadedModelDir) {
+    _recognizer = null;
+    _loadedModelDir = null;
+  }
+}
+function getConfig() {
+  return _config;
+}
+async function* transcribe(raw, startSec, endSec) {
+  if (_config.recognizer !== void 0) {
+    for await (const chunk of _config.recognizer(raw, startSec, endSec)) {
+      yield typeof chunk === "string" ? ENC.encode(chunk) : chunk;
+    }
+    return;
+  }
+  if (_config.modelDir !== void 0) {
+    const isWav = raw.byteLength >= 12 && DEC.decode(raw.subarray(0, 4)) === "RIFF";
+    if (!isWav) {
+      throw new Error(
+        "Built-in transcriber handles WAV only. For MP3/OGG/other, pass a custom transcriber via configure({ recognizer: (raw, startSec?, endSec?) => AsyncIterable<string | Uint8Array> })."
+      );
+    }
+    const { WaveFile } = loadWavefile();
+    const w = new WaveFile(raw);
+    w.toSampleRate(16e3);
+    w.toBitDepth("32f");
+    let samples = w.getSamples(true, Float32Array);
+    if (startSec !== void 0 || endSec !== void 0) {
+      const s = Math.max(0, Math.floor((startSec ?? 0) * 16e3));
+      const e = endSec !== void 0 ? Math.min(samples.length, Math.floor(endSec * 16e3)) : samples.length;
+      samples = samples.subarray(s, e);
+    }
+    const recognizer = getRecognizer(_config.modelDir);
+    const stream2 = recognizer.createStream();
+    stream2.acceptWaveform({ sampleRate: 16e3, samples });
+    const result = await recognizer.decodeAsync(stream2);
+    const text = result.text.trim();
+    if (text !== "") yield ENC.encode(`${text}
+`);
+    return;
+  }
+  throw new Error(
+    "Audio transcription not configured. Call configure({ modelDir }) to use the built-in sherpa-onnx+wavefile pipeline, or configure({ recognizer }) to plug your own."
+  );
+}
+async function metadata(raw) {
+  const parsed = await parseBuffer(raw, void 0, { duration: true });
+  const f = parsed.format;
+  return {
+    duration: f.duration ?? null,
+    sampleRate: f.sampleRate ?? null,
+    channels: f.numberOfChannels ?? null,
+    bitrate: f.bitrate !== void 0 ? f.bitrate / 1e3 : null
+  };
+}
+function estimateByteRange(meta, fileSize, startSec, endSec) {
+  const duration = meta.duration ?? 0;
+  if (duration <= 0) return [0, fileSize];
+  const start = startSec ?? 0;
+  const end = endSec ?? duration;
+  const ratioStart = Math.max(0, start / duration);
+  const ratioEnd = Math.min(1, end / duration);
+  return [Math.floor(ratioStart * fileSize), Math.floor(ratioEnd * fileSize)];
+}
+function formatDuration(duration) {
+  const total = Math.floor(duration);
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const seconds = total % 60;
+  const mm = String(minutes).padStart(2, "0");
+  const ss = String(seconds).padStart(2, "0");
+  if (hours > 0) return `${String(hours)}:${mm}:${ss}`;
+  return `${String(minutes)}:${ss}`;
+}
+function formatMetadata(meta, path, fileSize) {
+  const lines = [`${path}:`];
+  const { duration, sampleRate, channels, bitrate } = meta;
+  if (duration !== null) lines.push(`  Duration: ${formatDuration(duration)}`);
+  else lines.push("  Duration: unknown");
+  if (sampleRate !== null) lines.push(`  Sample rate: ${String(Math.floor(sampleRate))} Hz`);
+  if (channels !== null) {
+    const ch = Math.floor(channels);
+    const label = ch === 1 ? "mono" : ch === 2 ? "stereo" : `${String(ch)} channels`;
+    lines.push(`  Channels: ${String(ch)} (${label})`);
+  }
+  if (bitrate !== null) lines.push(`  Bitrate: ${bitrate.toFixed(1)} kbps`);
+  if (fileSize !== void 0 && fileSize !== null) {
+    if (fileSize >= 1048576) lines.push(`  File size: ${(fileSize / 1048576).toFixed(1)} MB`);
+    else if (fileSize >= 1024) lines.push(`  File size: ${(fileSize / 1024).toFixed(1)} KB`);
+    else lines.push(`  File size: ${String(fileSize)} B`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/local_audio/disk/cat_mp3.ts
+var ENC2 = new TextEncoder();
+async function catMp3Command(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult({ exitCode: 1, stderr: ENC2.encode("cat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult()];
+  try {
+    const raw = await materialize(stream(accessor, first));
+    const out = transcribe(raw);
+    return [out, new IOResult({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult({
+        exitCode: 1,
+        stderr: ENC2.encode(`cat: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_CAT_MP3 = command({
+  name: "cat",
+  resource: ResourceName5.DISK,
+  spec: specOf("cat"),
+  filetype: ".mp3",
+  fn: catMp3Command
+});
+
+// src/commands/local_audio/disk/cat_ogg.ts
+import {
+  IOResult as IOResult2,
+  ResourceName as ResourceName6,
+  command as command2,
+  materialize as materialize2,
+  specOf as specOf2
+} from "@struktoai/mirage-core";
+var ENC3 = new TextEncoder();
+async function catOggCommand(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult2({ exitCode: 1, stderr: ENC3.encode("cat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult2()];
+  try {
+    const raw = await materialize2(stream(accessor, first));
+    const out = transcribe(raw);
+    return [out, new IOResult2({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult2({
+        exitCode: 1,
+        stderr: ENC3.encode(`cat: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_CAT_OGG = command2({
+  name: "cat",
+  resource: ResourceName6.DISK,
+  spec: specOf2("cat"),
+  filetype: ".ogg",
+  fn: catOggCommand
+});
+
+// src/commands/local_audio/disk/cat_wav.ts
+import {
+  IOResult as IOResult3,
+  ResourceName as ResourceName7,
+  command as command3,
+  materialize as materialize3,
+  specOf as specOf3
+} from "@struktoai/mirage-core";
+var ENC4 = new TextEncoder();
+async function catWavCommand(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult3({ exitCode: 1, stderr: ENC4.encode("cat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult3()];
+  try {
+    const raw = await materialize3(stream(accessor, first));
+    const out = transcribe(raw);
+    return [out, new IOResult3({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult3({
+        exitCode: 1,
+        stderr: ENC4.encode(`cat: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_CAT_WAV = command3({
+  name: "cat",
+  resource: ResourceName7.DISK,
+  spec: specOf3("cat"),
+  filetype: ".wav",
+  fn: catWavCommand
+});
+
+// src/commands/local_audio/disk/grep_mp3.ts
+import {
+  IOResult as IOResult4,
+  ResourceName as ResourceName8,
+  command as command4,
+  materialize as materialize4,
+  specOf as specOf4
+} from "@struktoai/mirage-core";
+var ENC5 = new TextEncoder();
+var DEC2 = new TextDecoder();
+async function grepMp3Command(accessor, paths, texts, opts) {
+  if (paths.length === 0 || texts.length === 0) {
+    return [null, new IOResult4({ exitCode: 1, stderr: ENC5.encode("grep: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult4()];
+  const pattern = texts[0] ?? "";
+  const ignoreCase = opts.flags.i === true;
+  try {
+    const raw = await materialize4(stream(accessor, first));
+    const text = DEC2.decode(await materialize4(transcribe(raw)));
+    const flags = ignoreCase ? "i" : "";
+    const re = new RegExp(pattern, flags);
+    if (re.test(text)) {
+      const out = ENC5.encode(text);
+      return [out, new IOResult4({ reads: { [first.original]: raw }, cache: [first.original] })];
+    }
+    return [
+      null,
+      new IOResult4({
+        exitCode: 1,
+        reads: { [first.original]: raw },
+        cache: [first.original]
+      })
+    ];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult4({
+        exitCode: 1,
+        stderr: ENC5.encode(`grep: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_GREP_MP3 = command4({
+  name: "grep",
+  resource: ResourceName8.DISK,
+  spec: specOf4("grep"),
+  filetype: ".mp3",
+  fn: grepMp3Command
+});
+
+// src/commands/local_audio/disk/grep_ogg.ts
+import {
+  IOResult as IOResult5,
+  ResourceName as ResourceName9,
+  command as command5,
+  materialize as materialize5,
+  specOf as specOf5
+} from "@struktoai/mirage-core";
+var ENC6 = new TextEncoder();
+var DEC3 = new TextDecoder();
+async function grepOggCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0 || texts.length === 0) {
+    return [null, new IOResult5({ exitCode: 1, stderr: ENC6.encode("grep: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult5()];
+  const pattern = texts[0] ?? "";
+  const ignoreCase = opts.flags.i === true;
+  try {
+    const raw = await materialize5(stream(accessor, first));
+    const text = DEC3.decode(await materialize5(transcribe(raw)));
+    const flags = ignoreCase ? "i" : "";
+    const re = new RegExp(pattern, flags);
+    if (re.test(text)) {
+      const out = ENC6.encode(text);
+      return [out, new IOResult5({ reads: { [first.original]: raw }, cache: [first.original] })];
+    }
+    return [
+      null,
+      new IOResult5({
+        exitCode: 1,
+        reads: { [first.original]: raw },
+        cache: [first.original]
+      })
+    ];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult5({
+        exitCode: 1,
+        stderr: ENC6.encode(`grep: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_GREP_OGG = command5({
+  name: "grep",
+  resource: ResourceName9.DISK,
+  spec: specOf5("grep"),
+  filetype: ".ogg",
+  fn: grepOggCommand
+});
+
+// src/commands/local_audio/disk/grep_wav.ts
+import {
+  IOResult as IOResult6,
+  ResourceName as ResourceName10,
+  command as command6,
+  materialize as materialize6,
+  specOf as specOf6
+} from "@struktoai/mirage-core";
+var ENC7 = new TextEncoder();
+var DEC4 = new TextDecoder();
+async function grepWavCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0 || texts.length === 0) {
+    return [null, new IOResult6({ exitCode: 1, stderr: ENC7.encode("grep: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult6()];
+  const pattern = texts[0] ?? "";
+  const ignoreCase = opts.flags.i === true;
+  try {
+    const raw = await materialize6(stream(accessor, first));
+    const text = DEC4.decode(await materialize6(transcribe(raw)));
+    const flags = ignoreCase ? "i" : "";
+    const re = new RegExp(pattern, flags);
+    if (re.test(text)) {
+      const out = ENC7.encode(text);
+      return [out, new IOResult6({ reads: { [first.original]: raw }, cache: [first.original] })];
+    }
+    return [
+      null,
+      new IOResult6({
+        exitCode: 1,
+        reads: { [first.original]: raw },
+        cache: [first.original]
+      })
+    ];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult6({
+        exitCode: 1,
+        stderr: ENC7.encode(`grep: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_GREP_WAV = command6({
+  name: "grep",
+  resource: ResourceName10.DISK,
+  spec: specOf6("grep"),
+  filetype: ".wav",
+  fn: grepWavCommand
+});
+
+// src/commands/local_audio/disk/head_mp3.ts
+import {
+  IOResult as IOResult7,
+  ResourceName as ResourceName11,
+  command as command7,
+  materialize as materialize7,
+  specOf as specOf7
+} from "@struktoai/mirage-core";
+var ENC8 = new TextEncoder();
+async function headMp3Command(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult7({ exitCode: 1, stderr: ENC8.encode("head: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult7()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult7({ exitCode: 1, stderr: ENC8.encode("head: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = await materialize7(stream(accessor, first));
+    const out = transcribe(raw, void 0, n);
+    return [out, new IOResult7({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult7({
+        exitCode: 1,
+        stderr: ENC8.encode(`head: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_HEAD_MP3 = command7({
+  name: "head",
+  resource: ResourceName11.DISK,
+  spec: specOf7("head"),
+  filetype: ".mp3",
+  fn: headMp3Command
+});
+
+// src/commands/local_audio/disk/head_ogg.ts
+import {
+  IOResult as IOResult8,
+  ResourceName as ResourceName12,
+  command as command8,
+  materialize as materialize8,
+  specOf as specOf8
+} from "@struktoai/mirage-core";
+var ENC9 = new TextEncoder();
+async function headOggCommand(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult8({ exitCode: 1, stderr: ENC9.encode("head: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult8()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult8({ exitCode: 1, stderr: ENC9.encode("head: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = await materialize8(stream(accessor, first));
+    const out = transcribe(raw, void 0, n);
+    return [out, new IOResult8({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult8({
+        exitCode: 1,
+        stderr: ENC9.encode(`head: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_HEAD_OGG = command8({
+  name: "head",
+  resource: ResourceName12.DISK,
+  spec: specOf8("head"),
+  filetype: ".ogg",
+  fn: headOggCommand
+});
+
+// src/commands/local_audio/disk/head_wav.ts
+import {
+  IOResult as IOResult9,
+  ResourceName as ResourceName13,
+  command as command9,
+  materialize as materialize9,
+  specOf as specOf9
+} from "@struktoai/mirage-core";
+var ENC10 = new TextEncoder();
+async function headWavCommand(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult9({ exitCode: 1, stderr: ENC10.encode("head: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult9()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult9({ exitCode: 1, stderr: ENC10.encode("head: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = await materialize9(stream(accessor, first));
+    const out = transcribe(raw, void 0, n);
+    return [out, new IOResult9({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult9({
+        exitCode: 1,
+        stderr: ENC10.encode(`head: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_HEAD_WAV = command9({
+  name: "head",
+  resource: ResourceName13.DISK,
+  spec: specOf9("head"),
+  filetype: ".wav",
+  fn: headWavCommand
+});
+
+// src/commands/local_audio/disk/stat_mp3.ts
+import {
+  IOResult as IOResult10,
+  ResourceName as ResourceName14,
+  command as command10,
+  materialize as materialize10,
+  specOf as specOf10
+} from "@struktoai/mirage-core";
+var ENC11 = new TextEncoder();
+async function statMp3Command(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult10({ exitCode: 1, stderr: ENC11.encode("stat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult10()];
+  try {
+    const raw = await materialize10(stream(accessor, first));
+    const meta = await metadata(raw);
+    const fs2 = await stat(accessor, first);
+    const out = ENC11.encode(formatMetadata(meta, first.original, fs2.size ?? null));
+    return [out, new IOResult10({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult10({
+        exitCode: 1,
+        stderr: ENC11.encode(`stat: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_STAT_MP3 = command10({
+  name: "stat",
+  resource: ResourceName14.DISK,
+  spec: specOf10("stat"),
+  filetype: ".mp3",
+  fn: statMp3Command
+});
+
+// src/commands/local_audio/disk/stat_ogg.ts
+import {
+  IOResult as IOResult11,
+  ResourceName as ResourceName15,
+  command as command11,
+  materialize as materialize11,
+  specOf as specOf11
+} from "@struktoai/mirage-core";
+var ENC12 = new TextEncoder();
+async function statOggCommand(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult11({ exitCode: 1, stderr: ENC12.encode("stat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult11()];
+  try {
+    const raw = await materialize11(stream(accessor, first));
+    const meta = await metadata(raw);
+    const fs2 = await stat(accessor, first);
+    const out = ENC12.encode(formatMetadata(meta, first.original, fs2.size ?? null));
+    return [out, new IOResult11({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult11({
+        exitCode: 1,
+        stderr: ENC12.encode(`stat: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_STAT_OGG = command11({
+  name: "stat",
+  resource: ResourceName15.DISK,
+  spec: specOf11("stat"),
+  filetype: ".ogg",
+  fn: statOggCommand
+});
+
+// src/commands/local_audio/disk/stat_wav.ts
+import {
+  IOResult as IOResult12,
+  ResourceName as ResourceName16,
+  command as command12,
+  materialize as materialize12,
+  specOf as specOf12
+} from "@struktoai/mirage-core";
+var ENC13 = new TextEncoder();
+async function statWavCommand(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult12({ exitCode: 1, stderr: ENC13.encode("stat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult12()];
+  try {
+    const raw = await materialize12(stream(accessor, first));
+    const meta = await metadata(raw);
+    const fs2 = await stat(accessor, first);
+    const out = ENC13.encode(formatMetadata(meta, first.original, fs2.size ?? null));
+    return [out, new IOResult12({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult12({
+        exitCode: 1,
+        stderr: ENC13.encode(`stat: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_STAT_WAV = command12({
+  name: "stat",
+  resource: ResourceName16.DISK,
+  spec: specOf12("stat"),
+  filetype: ".wav",
+  fn: statWavCommand
+});
+
+// src/commands/local_audio/disk/tail_mp3.ts
+import {
+  IOResult as IOResult13,
+  ResourceName as ResourceName17,
+  command as command13,
+  materialize as materialize13,
+  specOf as specOf13
+} from "@struktoai/mirage-core";
+var ENC14 = new TextEncoder();
+async function tailMp3Command(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult13({ exitCode: 1, stderr: ENC14.encode("tail: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult13()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult13({ exitCode: 1, stderr: ENC14.encode("tail: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = await materialize13(stream(accessor, first));
+    const meta = await metadata(raw);
+    const duration = meta.duration ?? 0;
+    const start = Math.max(0, duration - n);
+    const out = transcribe(raw, start);
+    return [out, new IOResult13({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult13({
+        exitCode: 1,
+        stderr: ENC14.encode(`tail: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_TAIL_MP3 = command13({
+  name: "tail",
+  resource: ResourceName17.DISK,
+  spec: specOf13("tail"),
+  filetype: ".mp3",
+  fn: tailMp3Command
+});
+
+// src/commands/local_audio/disk/tail_ogg.ts
+import {
+  IOResult as IOResult14,
+  ResourceName as ResourceName18,
+  command as command14,
+  materialize as materialize14,
+  specOf as specOf14
+} from "@struktoai/mirage-core";
+var ENC15 = new TextEncoder();
+async function tailOggCommand(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult14({ exitCode: 1, stderr: ENC15.encode("tail: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult14()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult14({ exitCode: 1, stderr: ENC15.encode("tail: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = await materialize14(stream(accessor, first));
+    const meta = await metadata(raw);
+    const duration = meta.duration ?? 0;
+    const start = Math.max(0, duration - n);
+    const out = transcribe(raw, start);
+    return [out, new IOResult14({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult14({
+        exitCode: 1,
+        stderr: ENC15.encode(`tail: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_TAIL_OGG = command14({
+  name: "tail",
+  resource: ResourceName18.DISK,
+  spec: specOf14("tail"),
+  filetype: ".ogg",
+  fn: tailOggCommand
+});
+
+// src/commands/local_audio/disk/tail_wav.ts
+import {
+  IOResult as IOResult15,
+  ResourceName as ResourceName19,
+  command as command15,
+  materialize as materialize15,
+  specOf as specOf15
+} from "@struktoai/mirage-core";
+var ENC16 = new TextEncoder();
+async function tailWavCommand(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult15({ exitCode: 1, stderr: ENC16.encode("tail: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult15()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult15({ exitCode: 1, stderr: ENC16.encode("tail: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = await materialize15(stream(accessor, first));
+    const meta = await metadata(raw);
+    const duration = meta.duration ?? 0;
+    const start = Math.max(0, duration - n);
+    const out = transcribe(raw, start);
+    return [out, new IOResult15({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult15({
+        exitCode: 1,
+        stderr: ENC16.encode(`tail: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var DISK_LOCAL_AUDIO_TAIL_WAV = command15({
+  name: "tail",
+  resource: ResourceName19.DISK,
+  spec: specOf15("tail"),
+  filetype: ".wav",
+  fn: tailWavCommand
+});
+
+// src/commands/local_audio/disk/index.ts
+var DISK_LOCAL_AUDIO_COMMANDS = [
+  ...DISK_LOCAL_AUDIO_CAT_WAV,
+  ...DISK_LOCAL_AUDIO_CAT_MP3,
+  ...DISK_LOCAL_AUDIO_CAT_OGG,
+  ...DISK_LOCAL_AUDIO_HEAD_WAV,
+  ...DISK_LOCAL_AUDIO_HEAD_MP3,
+  ...DISK_LOCAL_AUDIO_HEAD_OGG,
+  ...DISK_LOCAL_AUDIO_TAIL_WAV,
+  ...DISK_LOCAL_AUDIO_TAIL_MP3,
+  ...DISK_LOCAL_AUDIO_TAIL_OGG,
+  ...DISK_LOCAL_AUDIO_GREP_WAV,
+  ...DISK_LOCAL_AUDIO_GREP_MP3,
+  ...DISK_LOCAL_AUDIO_GREP_OGG,
+  ...DISK_LOCAL_AUDIO_STAT_WAV,
+  ...DISK_LOCAL_AUDIO_STAT_MP3,
+  ...DISK_LOCAL_AUDIO_STAT_OGG
+];
+
+// src/commands/local_audio/ram/cat_mp3.ts
+import {
+  IOResult as IOResult16,
+  ResourceName as ResourceName20,
+  command as command16,
+  specOf as specOf16
+} from "@struktoai/mirage-core";
+
+// src/commands/local_audio/ram/read.ts
+function norm(p) {
+  return `/${p.replace(/^\/+|\/+$/g, "")}`;
+}
+function readRam(accessor, path) {
+  const p = norm(path.stripPrefix);
+  const data = accessor.store.files.get(p);
+  if (data === void 0) throw new Error(`file not found: ${p}`);
+  return data;
+}
+
+// src/commands/local_audio/ram/cat_mp3.ts
+var ENC17 = new TextEncoder();
+function catMp3Command2(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult16({ exitCode: 1, stderr: ENC17.encode("cat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult16()];
+  try {
+    const raw = readRam(accessor, first);
+    const out = transcribe(raw);
+    return [out, new IOResult16({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult16({
+        exitCode: 1,
+        stderr: ENC17.encode(`cat: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_CAT_MP3 = command16({
+  name: "cat",
+  resource: ResourceName20.RAM,
+  spec: specOf16("cat"),
+  filetype: ".mp3",
+  fn: catMp3Command2
+});
+
+// src/commands/local_audio/ram/cat_ogg.ts
+import {
+  IOResult as IOResult17,
+  ResourceName as ResourceName21,
+  command as command17,
+  specOf as specOf17
+} from "@struktoai/mirage-core";
+var ENC18 = new TextEncoder();
+function catOggCommand2(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult17({ exitCode: 1, stderr: ENC18.encode("cat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult17()];
+  try {
+    const raw = readRam(accessor, first);
+    const out = transcribe(raw);
+    return [out, new IOResult17({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult17({
+        exitCode: 1,
+        stderr: ENC18.encode(`cat: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_CAT_OGG = command17({
+  name: "cat",
+  resource: ResourceName21.RAM,
+  spec: specOf17("cat"),
+  filetype: ".ogg",
+  fn: catOggCommand2
+});
+
+// src/commands/local_audio/ram/cat_wav.ts
+import {
+  IOResult as IOResult18,
+  ResourceName as ResourceName22,
+  command as command18,
+  specOf as specOf18
+} from "@struktoai/mirage-core";
+var ENC19 = new TextEncoder();
+function catWavCommand2(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult18({ exitCode: 1, stderr: ENC19.encode("cat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult18()];
+  try {
+    const raw = readRam(accessor, first);
+    const out = transcribe(raw);
+    return [out, new IOResult18({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult18({
+        exitCode: 1,
+        stderr: ENC19.encode(`cat: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_CAT_WAV = command18({
+  name: "cat",
+  resource: ResourceName22.RAM,
+  spec: specOf18("cat"),
+  filetype: ".wav",
+  fn: catWavCommand2
+});
+
+// src/commands/local_audio/ram/grep_mp3.ts
+import {
+  IOResult as IOResult19,
+  ResourceName as ResourceName23,
+  command as command19,
+  materialize as materialize16,
+  specOf as specOf19
+} from "@struktoai/mirage-core";
+var ENC20 = new TextEncoder();
+var DEC5 = new TextDecoder();
+async function grepMp3Command2(accessor, paths, texts, opts) {
+  if (paths.length === 0 || texts.length === 0) {
+    return [null, new IOResult19({ exitCode: 1, stderr: ENC20.encode("grep: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult19()];
+  const pattern = texts[0] ?? "";
+  const ignoreCase = opts.flags.i === true;
+  try {
+    const raw = readRam(accessor, first);
+    const text = DEC5.decode(await materialize16(transcribe(raw)));
+    const flags = ignoreCase ? "i" : "";
+    const re = new RegExp(pattern, flags);
+    if (re.test(text)) {
+      const out = ENC20.encode(text);
+      return [out, new IOResult19({ reads: { [first.original]: raw }, cache: [first.original] })];
+    }
+    return [
+      null,
+      new IOResult19({
+        exitCode: 1,
+        reads: { [first.original]: raw },
+        cache: [first.original]
+      })
+    ];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult19({
+        exitCode: 1,
+        stderr: ENC20.encode(`grep: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_GREP_MP3 = command19({
+  name: "grep",
+  resource: ResourceName23.RAM,
+  spec: specOf19("grep"),
+  filetype: ".mp3",
+  fn: grepMp3Command2
+});
+
+// src/commands/local_audio/ram/grep_ogg.ts
+import {
+  IOResult as IOResult20,
+  ResourceName as ResourceName24,
+  command as command20,
+  materialize as materialize17,
+  specOf as specOf20
+} from "@struktoai/mirage-core";
+var ENC21 = new TextEncoder();
+var DEC6 = new TextDecoder();
+async function grepOggCommand2(accessor, paths, texts, opts) {
+  if (paths.length === 0 || texts.length === 0) {
+    return [null, new IOResult20({ exitCode: 1, stderr: ENC21.encode("grep: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult20()];
+  const pattern = texts[0] ?? "";
+  const ignoreCase = opts.flags.i === true;
+  try {
+    const raw = readRam(accessor, first);
+    const text = DEC6.decode(await materialize17(transcribe(raw)));
+    const flags = ignoreCase ? "i" : "";
+    const re = new RegExp(pattern, flags);
+    if (re.test(text)) {
+      const out = ENC21.encode(text);
+      return [out, new IOResult20({ reads: { [first.original]: raw }, cache: [first.original] })];
+    }
+    return [
+      null,
+      new IOResult20({
+        exitCode: 1,
+        reads: { [first.original]: raw },
+        cache: [first.original]
+      })
+    ];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult20({
+        exitCode: 1,
+        stderr: ENC21.encode(`grep: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_GREP_OGG = command20({
+  name: "grep",
+  resource: ResourceName24.RAM,
+  spec: specOf20("grep"),
+  filetype: ".ogg",
+  fn: grepOggCommand2
+});
+
+// src/commands/local_audio/ram/grep_wav.ts
+import {
+  IOResult as IOResult21,
+  ResourceName as ResourceName25,
+  command as command21,
+  materialize as materialize18,
+  specOf as specOf21
+} from "@struktoai/mirage-core";
+var ENC22 = new TextEncoder();
+var DEC7 = new TextDecoder();
+async function grepWavCommand2(accessor, paths, texts, opts) {
+  if (paths.length === 0 || texts.length === 0) {
+    return [null, new IOResult21({ exitCode: 1, stderr: ENC22.encode("grep: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult21()];
+  const pattern = texts[0] ?? "";
+  const ignoreCase = opts.flags.i === true;
+  try {
+    const raw = readRam(accessor, first);
+    const text = DEC7.decode(await materialize18(transcribe(raw)));
+    const flags = ignoreCase ? "i" : "";
+    const re = new RegExp(pattern, flags);
+    if (re.test(text)) {
+      const out = ENC22.encode(text);
+      return [out, new IOResult21({ reads: { [first.original]: raw }, cache: [first.original] })];
+    }
+    return [
+      null,
+      new IOResult21({
+        exitCode: 1,
+        reads: { [first.original]: raw },
+        cache: [first.original]
+      })
+    ];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult21({
+        exitCode: 1,
+        stderr: ENC22.encode(`grep: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_GREP_WAV = command21({
+  name: "grep",
+  resource: ResourceName25.RAM,
+  spec: specOf21("grep"),
+  filetype: ".wav",
+  fn: grepWavCommand2
+});
+
+// src/commands/local_audio/ram/head_mp3.ts
+import {
+  IOResult as IOResult22,
+  ResourceName as ResourceName26,
+  command as command22,
+  specOf as specOf22
+} from "@struktoai/mirage-core";
+var ENC23 = new TextEncoder();
+function headMp3Command2(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult22({ exitCode: 1, stderr: ENC23.encode("head: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult22()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult22({ exitCode: 1, stderr: ENC23.encode("head: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = readRam(accessor, first);
+    const out = transcribe(raw, void 0, n);
+    return [out, new IOResult22({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult22({
+        exitCode: 1,
+        stderr: ENC23.encode(`head: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_HEAD_MP3 = command22({
+  name: "head",
+  resource: ResourceName26.RAM,
+  spec: specOf22("head"),
+  filetype: ".mp3",
+  fn: headMp3Command2
+});
+
+// src/commands/local_audio/ram/head_ogg.ts
+import {
+  IOResult as IOResult23,
+  ResourceName as ResourceName27,
+  command as command23,
+  specOf as specOf23
+} from "@struktoai/mirage-core";
+var ENC24 = new TextEncoder();
+function headOggCommand2(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult23({ exitCode: 1, stderr: ENC24.encode("head: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult23()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult23({ exitCode: 1, stderr: ENC24.encode("head: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = readRam(accessor, first);
+    const out = transcribe(raw, void 0, n);
+    return [out, new IOResult23({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult23({
+        exitCode: 1,
+        stderr: ENC24.encode(`head: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_HEAD_OGG = command23({
+  name: "head",
+  resource: ResourceName27.RAM,
+  spec: specOf23("head"),
+  filetype: ".ogg",
+  fn: headOggCommand2
+});
+
+// src/commands/local_audio/ram/head_wav.ts
+import {
+  IOResult as IOResult24,
+  ResourceName as ResourceName28,
+  command as command24,
+  specOf as specOf24
+} from "@struktoai/mirage-core";
+var ENC25 = new TextEncoder();
+function headWavCommand2(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult24({ exitCode: 1, stderr: ENC25.encode("head: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult24()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult24({ exitCode: 1, stderr: ENC25.encode("head: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = readRam(accessor, first);
+    const out = transcribe(raw, void 0, n);
+    return [out, new IOResult24({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult24({
+        exitCode: 1,
+        stderr: ENC25.encode(`head: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_HEAD_WAV = command24({
+  name: "head",
+  resource: ResourceName28.RAM,
+  spec: specOf24("head"),
+  filetype: ".wav",
+  fn: headWavCommand2
+});
+
+// src/commands/local_audio/ram/stat_mp3.ts
+import {
+  IOResult as IOResult25,
+  ResourceName as ResourceName29,
+  command as command25,
+  specOf as specOf25
+} from "@struktoai/mirage-core";
+var ENC26 = new TextEncoder();
+async function statMp3Command2(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult25({ exitCode: 1, stderr: ENC26.encode("stat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult25()];
+  try {
+    const raw = readRam(accessor, first);
+    const meta = await metadata(raw);
+    const out = ENC26.encode(formatMetadata(meta, first.original, null));
+    return [out, new IOResult25({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult25({
+        exitCode: 1,
+        stderr: ENC26.encode(`stat: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_STAT_MP3 = command25({
+  name: "stat",
+  resource: ResourceName29.RAM,
+  spec: specOf25("stat"),
+  filetype: ".mp3",
+  fn: statMp3Command2
+});
+
+// src/commands/local_audio/ram/stat_ogg.ts
+import {
+  IOResult as IOResult26,
+  ResourceName as ResourceName30,
+  command as command26,
+  specOf as specOf26
+} from "@struktoai/mirage-core";
+var ENC27 = new TextEncoder();
+async function statOggCommand2(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult26({ exitCode: 1, stderr: ENC27.encode("stat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult26()];
+  try {
+    const raw = readRam(accessor, first);
+    const meta = await metadata(raw);
+    const out = ENC27.encode(formatMetadata(meta, first.original, null));
+    return [out, new IOResult26({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult26({
+        exitCode: 1,
+        stderr: ENC27.encode(`stat: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_STAT_OGG = command26({
+  name: "stat",
+  resource: ResourceName30.RAM,
+  spec: specOf26("stat"),
+  filetype: ".ogg",
+  fn: statOggCommand2
+});
+
+// src/commands/local_audio/ram/stat_wav.ts
+import {
+  IOResult as IOResult27,
+  ResourceName as ResourceName31,
+  command as command27,
+  specOf as specOf27
+} from "@struktoai/mirage-core";
+var ENC28 = new TextEncoder();
+async function statWavCommand2(accessor, paths, _texts, _opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult27({ exitCode: 1, stderr: ENC28.encode("stat: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult27()];
+  try {
+    const raw = readRam(accessor, first);
+    const meta = await metadata(raw);
+    const out = ENC28.encode(formatMetadata(meta, first.original, null));
+    return [out, new IOResult27({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult27({
+        exitCode: 1,
+        stderr: ENC28.encode(`stat: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_STAT_WAV = command27({
+  name: "stat",
+  resource: ResourceName31.RAM,
+  spec: specOf27("stat"),
+  filetype: ".wav",
+  fn: statWavCommand2
+});
+
+// src/commands/local_audio/ram/tail_mp3.ts
+import {
+  IOResult as IOResult28,
+  ResourceName as ResourceName32,
+  command as command28,
+  specOf as specOf28
+} from "@struktoai/mirage-core";
+var ENC29 = new TextEncoder();
+async function tailMp3Command2(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult28({ exitCode: 1, stderr: ENC29.encode("tail: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult28()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult28({ exitCode: 1, stderr: ENC29.encode("tail: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = readRam(accessor, first);
+    const meta = await metadata(raw);
+    const duration = meta.duration ?? 0;
+    const start = Math.max(0, duration - n);
+    const out = transcribe(raw, start);
+    return [out, new IOResult28({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult28({
+        exitCode: 1,
+        stderr: ENC29.encode(`tail: ${first.original}: failed to read as mp3: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_TAIL_MP3 = command28({
+  name: "tail",
+  resource: ResourceName32.RAM,
+  spec: specOf28("tail"),
+  filetype: ".mp3",
+  fn: tailMp3Command2
+});
+
+// src/commands/local_audio/ram/tail_ogg.ts
+import {
+  IOResult as IOResult29,
+  ResourceName as ResourceName33,
+  command as command29,
+  specOf as specOf29
+} from "@struktoai/mirage-core";
+var ENC30 = new TextEncoder();
+async function tailOggCommand2(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult29({ exitCode: 1, stderr: ENC30.encode("tail: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult29()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult29({ exitCode: 1, stderr: ENC30.encode("tail: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = readRam(accessor, first);
+    const meta = await metadata(raw);
+    const duration = meta.duration ?? 0;
+    const start = Math.max(0, duration - n);
+    const out = transcribe(raw, start);
+    return [out, new IOResult29({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult29({
+        exitCode: 1,
+        stderr: ENC30.encode(`tail: ${first.original}: failed to read as ogg: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_TAIL_OGG = command29({
+  name: "tail",
+  resource: ResourceName33.RAM,
+  spec: specOf29("tail"),
+  filetype: ".ogg",
+  fn: tailOggCommand2
+});
+
+// src/commands/local_audio/ram/tail_wav.ts
+import {
+  IOResult as IOResult30,
+  ResourceName as ResourceName34,
+  command as command30,
+  specOf as specOf30
+} from "@struktoai/mirage-core";
+var ENC31 = new TextEncoder();
+async function tailWavCommand2(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult30({ exitCode: 1, stderr: ENC31.encode("tail: missing operand\n") })];
+  }
+  const first = paths[0];
+  if (first === void 0) return [null, new IOResult30()];
+  if (typeof opts.flags.c === "string") {
+    return [
+      null,
+      new IOResult30({ exitCode: 1, stderr: ENC31.encode("tail: -c not supported for audio files\n") })
+    ];
+  }
+  const n = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  try {
+    const raw = readRam(accessor, first);
+    const meta = await metadata(raw);
+    const duration = meta.duration ?? 0;
+    const start = Math.max(0, duration - n);
+    const out = transcribe(raw, start);
+    return [out, new IOResult30({ reads: { [first.original]: raw }, cache: [first.original] })];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [
+      null,
+      new IOResult30({
+        exitCode: 1,
+        stderr: ENC31.encode(`tail: ${first.original}: failed to read as wav: ${msg}
+`)
+      })
+    ];
+  }
+}
+var RAM_LOCAL_AUDIO_TAIL_WAV = command30({
+  name: "tail",
+  resource: ResourceName34.RAM,
+  spec: specOf30("tail"),
+  filetype: ".wav",
+  fn: tailWavCommand2
+});
+
+// src/commands/local_audio/ram/index.ts
+var RAM_LOCAL_AUDIO_COMMANDS = [
+  ...RAM_LOCAL_AUDIO_CAT_WAV,
+  ...RAM_LOCAL_AUDIO_CAT_MP3,
+  ...RAM_LOCAL_AUDIO_CAT_OGG,
+  ...RAM_LOCAL_AUDIO_HEAD_WAV,
+  ...RAM_LOCAL_AUDIO_HEAD_MP3,
+  ...RAM_LOCAL_AUDIO_HEAD_OGG,
+  ...RAM_LOCAL_AUDIO_TAIL_WAV,
+  ...RAM_LOCAL_AUDIO_TAIL_MP3,
+  ...RAM_LOCAL_AUDIO_TAIL_OGG,
+  ...RAM_LOCAL_AUDIO_GREP_WAV,
+  ...RAM_LOCAL_AUDIO_GREP_MP3,
+  ...RAM_LOCAL_AUDIO_GREP_OGG,
+  ...RAM_LOCAL_AUDIO_STAT_WAV,
+  ...RAM_LOCAL_AUDIO_STAT_MP3,
+  ...RAM_LOCAL_AUDIO_STAT_OGG
+];
+
+// src/commands/local_audio/index.ts
+var LOCAL_AUDIO_COMMANDS = {
+  ram: RAM_LOCAL_AUDIO_COMMANDS,
+  disk: DISK_LOCAL_AUDIO_COMMANDS
+};
+export {
+  BoxResource,
+  DISK_COMMANDS,
+  DISK_LOCAL_AUDIO_COMMANDS,
+  DISK_OPS,
+  DISK_PROMPT,
+  DiscordResource,
+  DiskResource,
+  DropboxResource,
+  EMAIL_COMMANDS,
+  EMAIL_OPS,
+  EMAIL_PROMPT,
+  EMAIL_WRITE_PROMPT,
+  EmailAccessor,
+  EmailResource,
+  FuseManager,
+  GCSResource,
+  GCS_ENDPOINT,
+  GCS_PROMPT,
+  GDocsResource,
+  GDriveResource,
+  GSheetsResource,
+  GSlidesResource,
+  GitHubCIResource,
+  GitHubResource,
+  GmailResource,
+  LOCAL_AUDIO_COMMANDS,
+  LangfuseResource,
+  LinearResource,
+  MirageFS,
+  MongoDBResource,
+  MongoDBStore,
+  OCIResource,
+  OCI_PROMPT,
+  PostHogResource,
+  PostgresResource,
+  PostgresStore,
+  R2Resource,
+  R2_PROMPT,
+  RAM_LOCAL_AUDIO_COMMANDS,
+  REDIS_COMMANDS,
+  REDIS_OPS,
+  REDIS_PROMPT,
+  RedisAccessor,
+  RedisFileCacheStore,
+  RedisIndexCacheStore,
+  RedisResource,
+  RedisStore,
+  S3Resource,
+  SSCholarAuthorResource,
+  SSCholarPaperResource,
+  SSHAccessor,
+  SSHResource,
+  SSH_COMMANDS,
+  SSH_OPS,
+  SSH_PROMPT,
+  SUPABASE_PROMPT,
+  SlackResource,
+  SupabaseResource,
+  TrelloResource,
+  VercelResource,
+  Workspace,
+  buildEmailConfig,
+  buildResource,
+  configure as configureLocalAudio,
+  fileReadProvision,
+  mount as fuseMount,
+  mountBackground as fuseMountBackground,
+  getConfig as getLocalAudioConfig,
+  headTailProvision,
+  isMacosMetadata,
+  knownResources,
+  estimateByteRange as localAudioEstimateByteRange,
+  formatDuration as localAudioFormatDuration,
+  formatMetadata as localAudioFormatMetadata,
+  metadata as localAudioMetadata,
+  transcribe as localAudioTranscribe,
+  metadataProvision,
+  nativeExec,
+  nativeExecStream,
+  normalizeBoxConfig,
+  normalizeDiscordConfig,
+  normalizeDropboxConfig,
+  normalizeEmailConfig,
+  normalizeGDocsConfig,
+  normalizeGDriveConfig,
+  normalizeGSheetsConfig,
+  normalizeGSlidesConfig,
+  normalizeGitHubCIConfig,
+  normalizeGitHubConfig,
+  normalizeGmailConfig,
+  normalizeLangfuseConfig,
+  normalizeLinearConfig,
+  normalizeSlackConfig,
+  normalizeSshConfig,
+  normalizeTrelloConfig,
+  patchNodeFs,
+  redactBoxConfig,
+  redactDiscordConfig,
+  redactDropboxConfig,
+  redactEmailConfig,
+  redactGDocsConfig,
+  redactGDriveConfig,
+  redactGSheetsConfig,
+  redactGSlidesConfig,
+  redactGcsConfig,
+  redactGitHubCIConfig,
+  redactGitHubConfig,
+  redactGmailConfig,
+  redactLangfuseConfig,
+  redactLinearConfig,
+  redactOciConfig,
+  redactR2Config,
+  redactConfig as redactS3Config,
+  redactSlackConfig,
+  redactSshConfig,
+  redactSupabaseConfig,
+  redactTrelloConfig,
+  register as registerResourceFactory,
+  resolvedSupabaseEndpoint
+};
+//# sourceMappingURL=index.js.map