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

package/dist/chunk-OSVZKYXS.js

@@ -0,0 +1,946 @@
+import {
+  loadOptionalPeer
+} from "./chunk-OQKNDS66.js";
+
+// src/resource/redis/redis.ts
+import {
+  BaseResource,
+  PathSpec,
+  REDACTED_SECRET,
+  ResourceName as ResourceName7,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf2
+} from "@struktoai/mirage-core";
+
+// src/commands/builtin/redis/index.ts
+import {
+  ResourceName as ResourceName5,
+  makeFiletypeCommands,
+  makeGenericCommands
+} from "@struktoai/mirage-core";
+
+// src/core/redis/read.ts
+import { record, ResourceName } from "@struktoai/mirage-core";
+import { enoent } from "@struktoai/mirage-core";
+
+// src/core/redis/utils.ts
+import { norm, parent, gnuBasename } from "@struktoai/mirage-core";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/core/redis/read.ts
+async function read(accessor, path, _index) {
+  const start = performance.now();
+  const p = norm(path.mountPath);
+  const data = await accessor.store.getFile(p);
+  if (data === null) {
+    throw enoent(path);
+  }
+  record("read", p, ResourceName.REDIS, data.byteLength, start);
+  return data;
+}
+
+// src/core/redis/stat.ts
+import {
+  FileStat,
+  FileType,
+  guessType
+} from "@struktoai/mirage-core";
+import { enoent as enoent2 } from "@struktoai/mirage-core";
+function decodeAttrs(raw) {
+  const out = {};
+  if (raw.mode !== void 0) out.mode = parseInt(raw.mode, 10);
+  for (const key of ["uid", "gid"]) {
+    const val = raw[key];
+    if (val !== void 0) out[key] = /^\d+$/.test(val) ? parseInt(val, 10) : val;
+  }
+  if (raw.atime !== void 0) out.atime = raw.atime;
+  return out;
+}
+async function stat(accessor, path, _index) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  if (await store.hasDir(p)) {
+    const attrs = decodeAttrs(await store.getAttrs(p));
+    return new FileStat({
+      name: gnuBasename(p),
+      modified: await store.getModified(p),
+      type: FileType.DIRECTORY,
+      mode: attrs.mode ?? null,
+      uid: attrs.uid ?? null,
+      gid: attrs.gid ?? null,
+      atime: attrs.atime ?? null
+    });
+  }
+  if (await store.hasFile(p)) {
+    const size = await store.fileLen(p);
+    const attrs = decodeAttrs(await store.getAttrs(p));
+    return new FileStat({
+      name: gnuBasename(p),
+      size,
+      modified: await store.getModified(p),
+      type: guessType(p),
+      mode: attrs.mode ?? null,
+      uid: attrs.uid ?? null,
+      gid: attrs.gid ?? null,
+      atime: attrs.atime ?? null
+    });
+  }
+  throw enoent2(path);
+}
+
+// src/core/redis/append.ts
+import { ResourceName as ResourceName2, invalidateAfterWrite, record as record2 } from "@struktoai/mirage-core";
+async function appendBytes(accessor, path, data) {
+  const start = performance.now();
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  const existing = await store.getFile(p);
+  if (existing !== null) {
+    const merged = new Uint8Array(existing.byteLength + data.byteLength);
+    merged.set(existing, 0);
+    merged.set(data, existing.byteLength);
+    await store.setFile(p, merged);
+  } else {
+    await store.setFile(p, data);
+  }
+  await store.setModified(p, nowIso());
+  record2("append", p, ResourceName2.REDIS, data.byteLength, start);
+  await invalidateAfterWrite(p);
+}
+
+// src/core/redis/constants.ts
+var SCOPE_ERROR = 5e4;
+
+// src/core/redis/copy.ts
+import { invalidateAfterWrite as invalidateAfterWrite2 } from "@struktoai/mirage-core";
+async function copy(accessor, src, dst) {
+  const s = norm(src.mountPath);
+  const d = norm(dst.mountPath);
+  const store = accessor.store;
+  const data = await store.getFile(s);
+  if (data === null) {
+    throw new Error(`file not found: ${s}`);
+  }
+  await store.setFile(d, data);
+  await store.setModified(d, nowIso());
+  await invalidateAfterWrite2(dst);
+}
+
+// src/core/redis/create.ts
+import { invalidateAfterWrite as invalidateAfterWrite3 } from "@struktoai/mirage-core";
+async function create(accessor, path) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  await store.setFile(p, new Uint8Array(0));
+  await store.setModified(p, nowIso());
+  await invalidateAfterWrite3(path);
+}
+
+// src/core/redis/du.ts
+import { rstripSlash } from "@struktoai/mirage-core";
+async function du(accessor, path) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  const prefix = rstripSlash(p) + "/";
+  let total = 0;
+  for (const key of await store.listFiles()) {
+    if (key === p || key.startsWith(prefix)) {
+      total += await store.fileLen(key);
+    }
+  }
+  return total;
+}
+async function duAll(accessor, path) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  const prefix = rstripSlash(p) + "/";
+  const entries = [];
+  let total = 0;
+  for (const key of await store.listFiles()) {
+    if (key === p || key.startsWith(prefix)) {
+      const size = await store.fileLen(key);
+      entries.push([key, size]);
+      total += size;
+    }
+  }
+  return { entries, total };
+}
+
+// src/core/redis/exists.ts
+async function exists(accessor, path) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  return await store.hasFile(p) || await store.hasDir(p);
+}
+
+// src/core/redis/find.ts
+import {
+  buildTree,
+  computeNonemptyDirs,
+  emitStartPath,
+  keep,
+  rstripSlash as rstripSlash2,
+  startBasename
+} from "@struktoai/mirage-core";
+async function find(accessor, path, options = {}) {
+  const p = norm(path.mountPath);
+  const startName = startBasename(path.virtual);
+  const store = accessor.store;
+  const prefix = rstripSlash2(p) + "/";
+  const baseDepth = p === "/" ? 0 : (p.match(/\//g) ?? []).length;
+  const results = [];
+  const tree = options.tree ?? buildTree({
+    name: options.name,
+    iname: options.iname,
+    pathPattern: options.pathPattern,
+    type: options.type,
+    nameExclude: options.nameExclude,
+    orNames: options.orNames,
+    empty: options.empty
+  });
+  const empty = options.empty === true;
+  const allFiles = await store.listFiles();
+  const allDirs = await store.listDirs();
+  const nonempty = empty ? computeNonemptyDirs([...allFiles, ...[...allDirs].filter((k) => k !== "/")]) : /* @__PURE__ */ new Set();
+  const candidates = [];
+  if (options.type !== "d") {
+    for (const key of allFiles) candidates.push([key, "f"]);
+  }
+  if (options.type !== "f") {
+    for (const key of allDirs) {
+      candidates.push([key, "d"]);
+    }
+  }
+  let rootKind = null;
+  let rootIsEmpty = null;
+  let rootSize = null;
+  for (const [key, kind] of candidates) {
+    if (key !== p && !key.startsWith(prefix)) continue;
+    if (key === p) {
+      rootKind = kind;
+      if (empty) {
+        rootIsEmpty = kind === "f" ? await store.fileLen(key) === 0 : !nonempty.has(key);
+      }
+      if (kind === "f") rootSize = await store.fileLen(key);
+      continue;
+    }
+    const depth = (key.match(/\//g) ?? []).length - baseDepth;
+    if (options.maxDepth !== null && options.maxDepth !== void 0 && depth > options.maxDepth)
+      continue;
+    const basename = key.slice(key.lastIndexOf("/") + 1);
+    let isEmpty = null;
+    if (empty) {
+      isEmpty = kind === "f" ? await store.fileLen(key) === 0 : !nonempty.has(key);
+    }
+    if (!keep({ key, name: basename, kind, depth, isEmpty }, tree, options.minDepth)) continue;
+    if (options.minSize != null || options.maxSize != null) {
+      const size = kind === "f" ? await store.fileLen(key) : 0;
+      if (options.minSize != null && size < options.minSize) continue;
+      if (options.maxSize != null && size > options.maxSize) continue;
+    }
+    results.push(key);
+  }
+  if (rootKind !== null) {
+    emitStartPath(results, p, startName, {
+      kind: rootKind,
+      isEmpty: rootIsEmpty,
+      exists: true,
+      tree,
+      maxDepth: options.maxDepth,
+      minDepth: options.minDepth,
+      size: rootSize,
+      minSize: options.minSize,
+      maxSize: options.maxSize
+    });
+  }
+  results.sort();
+  return results;
+}
+
+// src/core/redis/mkdir.ts
+import { invalidateAfterWrite as invalidateAfterWrite4, invalidateAncestors } from "@struktoai/mirage-core";
+import { stripSlash } from "@struktoai/mirage-core";
+async function mkdir(accessor, path, parents = false) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  if (parents) {
+    const parts = stripSlash(p).split("/");
+    let current = "";
+    const now = nowIso();
+    for (const part of parts) {
+      current += `/${part}`;
+      await store.addDir(current);
+      const mod = await store.getModified(current);
+      if (mod === null) {
+        await store.setModified(current, now);
+      }
+    }
+    await invalidateAfterWrite4(p);
+    await invalidateAncestors(path);
+    return;
+  }
+  const par = parent(p);
+  if (par !== "/" && !await store.hasDir(par)) {
+    throw new Error(`parent directory does not exist: ${par}`);
+  }
+  await store.addDir(p);
+  await store.setModified(p, nowIso());
+  await invalidateAfterWrite4(p);
+}
+
+// src/core/redis/readdir.ts
+import {
+  mountPrefixOf,
+  rstripSlash as rstripSlash3
+} from "@struktoai/mirage-core";
+import { enotdir } from "@struktoai/mirage-core";
+
+// src/core/redis/entry.ts
+import { IndexEntry } from "@struktoai/mirage-core";
+var RedisResourceType = Object.freeze({
+  FILE: "file",
+  FOLDER: "folder"
+});
+var RedisIndexEntry = class _RedisIndexEntry extends IndexEntry {
+  // size defaults to null, not 0: a readdir knows a key exists but not
+  // its length, and a lying 0 would be trusted by index-first size
+  // lookups (provision estimates) over a real stat.
+  static file(path, size = null) {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    return new _RedisIndexEntry({
+      id: path,
+      name,
+      resourceType: RedisResourceType.FILE,
+      vfsName: name,
+      size
+    });
+  }
+  static folder(path) {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    return new _RedisIndexEntry({
+      id: path,
+      name,
+      resourceType: RedisResourceType.FOLDER,
+      vfsName: name
+    });
+  }
+};
+
+// src/core/redis/readdir.ts
+async function readdir(accessor, path, index) {
+  const virtual = path.pattern !== null ? path.directory : path.mountPath;
+  const mountPrefix = mountPrefixOf(path.virtual, path.resourcePath);
+  const virtualKey = rstripSlash3(mountPrefix + virtual) || "/";
+  if (index !== void 0) {
+    const cached = await index.listDir(virtualKey);
+    if (cached.entries !== void 0 && cached.entries !== null) {
+      return cached.entries;
+    }
+  }
+  const store = accessor.store;
+  const p = norm(virtual);
+  if (!await store.hasDir(p)) {
+    throw enotdir(path);
+  }
+  const dirPrefix = p === "/" ? "/" : `${p}/`;
+  const seen = /* @__PURE__ */ new Set();
+  const files = await store.listFiles();
+  const dirs = await store.listDirs();
+  for (const key of [...files, ...dirs]) {
+    if (key === p) continue;
+    if (!key.startsWith(dirPrefix)) continue;
+    const remainder = key.slice(dirPrefix.length);
+    const first = remainder.split("/")[0];
+    if (first !== void 0 && first.length > 0) seen.add(dirPrefix + first);
+  }
+  const sorted = [...seen].sort();
+  const virtualEntries = sorted.map((entry) => `${mountPrefix}${entry}`);
+  if (index !== void 0) {
+    const fileSet = new Set(files);
+    const entries = sorted.map((e) => {
+      const name = e.slice(e.lastIndexOf("/") + 1);
+      return [name, fileSet.has(e) ? RedisIndexEntry.file(e) : RedisIndexEntry.folder(e)];
+    });
+    await index.setDir(virtualKey, entries);
+  }
+  return virtualEntries;
+}
+
+// src/core/redis/rename.ts
+import { invalidateAfterUnlink, invalidateAfterWrite as invalidateAfterWrite5 } from "@struktoai/mirage-core";
+import { rstripSlash as rstripSlash4 } from "@struktoai/mirage-core";
+async function rename(accessor, src, dst) {
+  const s = norm(src.mountPath);
+  const d = norm(dst.mountPath);
+  const now = nowIso();
+  const store = accessor.store;
+  if (await store.hasFile(s)) {
+    const data = await store.getFile(s);
+    const mod = await store.getModified(s);
+    const attrs = await store.getAttrs(s);
+    if (data === null) throw new Error(`file not found: ${s}`);
+    await store.delFile(s);
+    await store.delModified(s);
+    await store.delAttrs(s);
+    await store.setFile(d, data);
+    await store.setModified(d, mod ?? now);
+    if (Object.keys(attrs).length > 0) await store.setAttrs(d, attrs);
+    await invalidateAfterUnlink(s);
+    await invalidateAfterWrite5(d);
+    return;
+  }
+  if (await store.hasDir(s)) {
+    const mod = await store.getModified(s);
+    const attrs = await store.getAttrs(s);
+    await store.removeDir(s);
+    await store.delModified(s);
+    await store.delAttrs(s);
+    await store.addDir(d);
+    await store.setModified(d, mod ?? now);
+    if (Object.keys(attrs).length > 0) await store.setAttrs(d, attrs);
+    const prefix = rstripSlash4(s) + "/";
+    const dPrefix = rstripSlash4(d) + "/";
+    const files = await store.listFiles();
+    for (const key of files) {
+      if (key.startsWith(prefix)) {
+        const newKey = dPrefix + key.slice(prefix.length);
+        const data = await store.getFile(key);
+        if (data === null) continue;
+        const subAttrs = await store.getAttrs(key);
+        await store.delFile(key);
+        await store.delAttrs(key);
+        await store.setFile(newKey, data);
+        if (Object.keys(subAttrs).length > 0) await store.setAttrs(newKey, subAttrs);
+      }
+    }
+    await invalidateAfterUnlink(s);
+    await invalidateAfterWrite5(d);
+    return;
+  }
+  throw new Error(`file not found: ${s}`);
+}
+
+// src/core/redis/rm.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink2, rstripSlash as rstripSlash5 } from "@struktoai/mirage-core";
+async function rmR(accessor, path) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  const prefix = rstripSlash5(p) + "/";
+  const files = await store.listFiles();
+  for (const key of files) {
+    if (key === p || key.startsWith(prefix)) {
+      await store.delFile(key);
+      await store.delModified(key);
+      await store.delAttrs(key);
+    }
+  }
+  const dirs = await store.listDirs();
+  for (const key of dirs) {
+    if (key === p || key.startsWith(prefix)) {
+      await store.removeDir(key);
+      await store.delModified(key);
+      await store.delAttrs(key);
+    }
+  }
+  await invalidateAfterUnlink2(path);
+}
+
+// src/core/redis/rmdir.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink3, rstripSlash as rstripSlash6 } from "@struktoai/mirage-core";
+async function rmdir(accessor, path) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  if (!await store.hasDir(p)) {
+    throw new Error(`not a directory: ${p}`);
+  }
+  const prefix = rstripSlash6(p) + "/";
+  const files = await store.listFiles();
+  const dirs = await store.listDirs();
+  const candidates = [...files, ...dirs];
+  for (const k of candidates) {
+    if (k !== p && k.startsWith(prefix)) {
+      throw new Error(`directory not empty: ${p}`);
+    }
+  }
+  await store.removeDir(p);
+  await invalidateAfterUnlink3(path);
+}
+
+// src/core/redis/set_attrs.ts
+import { enoent as enoent3 } from "@struktoai/mirage-core";
+async function setAttrs(accessor, path, fields) {
+  const store = accessor.store;
+  const p = norm(path.mountPath);
+  if (!await store.hasFile(p) && !await store.hasDir(p)) {
+    throw enoent3(path);
+  }
+  const encoded = {};
+  if (fields.mode !== void 0) encoded.mode = String(fields.mode);
+  if (fields.uid !== void 0) encoded.uid = String(fields.uid);
+  if (fields.gid !== void 0) encoded.gid = String(fields.gid);
+  if (fields.atime !== void 0) encoded.atime = fields.atime;
+  if (Object.keys(encoded).length > 0) {
+    await store.setAttrs(p, encoded);
+  }
+  if (fields.mtime !== void 0) {
+    await store.setModified(p, fields.mtime);
+  }
+  return {};
+}
+
+// src/core/redis/stream.ts
+import {
+  recordStream,
+  ResourceName as ResourceName3
+} from "@struktoai/mirage-core";
+import { enoent as enoent4 } from "@struktoai/mirage-core";
+async function* stream(accessor, path, _index) {
+  const p = norm(path.mountPath);
+  const data = await accessor.store.getFile(p);
+  if (data === null) throw enoent4(path);
+  const rec = recordStream("read", p, ResourceName3.REDIS);
+  if (rec !== null) rec.bytes = data.byteLength;
+  yield data;
+}
+
+// src/core/redis/truncate.ts
+import { invalidateAfterWrite as invalidateAfterWrite6 } from "@struktoai/mirage-core";
+async function truncate(accessor, path, length) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  const existing = await store.getFile(p);
+  const data = existing ?? new Uint8Array(0);
+  const out = new Uint8Array(length);
+  const copyLen = Math.min(data.byteLength, length);
+  out.set(data.subarray(0, copyLen), 0);
+  await store.setFile(p, out);
+  await store.setModified(p, nowIso());
+  await invalidateAfterWrite6(p);
+}
+
+// src/core/redis/unlink.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink4 } from "@struktoai/mirage-core";
+async function unlink(accessor, path) {
+  const p = norm(path.mountPath);
+  const store = accessor.store;
+  if (!await store.hasFile(p)) {
+    throw new Error(`file not found: ${p}`);
+  }
+  await store.delFile(p);
+  await store.delModified(p);
+  await store.delAttrs(p);
+  await invalidateAfterUnlink4(p);
+}
+
+// src/core/redis/write.ts
+import { ResourceName as ResourceName4, invalidateAfterWrite as invalidateAfterWrite7, record as record3 } from "@struktoai/mirage-core";
+async function writeBytes(accessor, path, data) {
+  const start = performance.now();
+  const p = norm(path.mountPath);
+  const par = parent(p);
+  const store = accessor.store;
+  if (par !== "/" && !await store.hasDir(par)) {
+    throw new Error(`parent directory does not exist: ${par}`);
+  }
+  await store.setFile(p, data);
+  await store.setModified(p, nowIso());
+  record3("write", p, ResourceName4.REDIS, data.byteLength, start);
+  await invalidateAfterWrite7(p);
+}
+
+// src/commands/builtin/redis/io.ts
+var REDIS_IO = {
+  readdir,
+  readBytes: read,
+  readStream: stream,
+  stat,
+  isMounted: () => true,
+  local: true,
+  maxGlobMatches: SCOPE_ERROR,
+  write: writeBytes,
+  exists,
+  mkdir,
+  unlink,
+  rmdir,
+  rmR,
+  rename,
+  copy,
+  create,
+  truncate,
+  append: appendBytes,
+  setAttrs,
+  find,
+  duTotal: du,
+  duAll: async (accessor, path) => {
+    const { entries, total } = await duAll(accessor, path);
+    return [entries, total];
+  }
+};
+
+// src/commands/builtin/redis/index.ts
+var REDIS_COMMANDS = [
+  ...makeFiletypeCommands({
+    resource: ResourceName5.REDIS,
+    readBytes: read,
+    statEntry: stat
+  }),
+  ...makeGenericCommands(ResourceName5.REDIS, REDIS_IO)
+];
+
+// src/accessor/redis.ts
+import { Accessor } from "@struktoai/mirage-core";
+var RedisAccessor = class extends Accessor {
+  store;
+  constructor(store) {
+    super();
+    this.store = store;
+  }
+};
+
+// src/ops/redis/index.ts
+import { ResourceName as ResourceName6, makeGenericOps } from "@struktoai/mirage-core";
+var REDIS_OPS = makeGenericOps(ResourceName6.REDIS, REDIS_IO, {
+  filetypeRead: [".feather", ".hdf5", ".parquet"],
+  forwardIndex: false
+});
+
+// src/resource/redis/prompt.ts
+var REDIS_PROMPT = `Redis-backed persistent filesystem. Behaves like a standard filesystem.
+Standard commands: ls, cat, head, tail, grep, wc, find, tree, mkdir, touch, cp, mv, rm, tee.`;
+
+// src/resource/redis/store.ts
+var RedisStore = class {
+  url;
+  keyPrefix;
+  providedClient;
+  clientPromise = null;
+  constructor(options = {}) {
+    this.url = options.url ?? "redis://localhost:6379/0";
+    this.keyPrefix = options.keyPrefix ?? "mirage:fs:";
+    this.providedClient = options.client ?? null;
+  }
+  fk(path) {
+    return `${this.keyPrefix}file:${path}`;
+  }
+  dk() {
+    return `${this.keyPrefix}dir`;
+  }
+  mk(path) {
+    return `${this.keyPrefix}modified:${path}`;
+  }
+  ak(path) {
+    return `${this.keyPrefix}attrs:${path}`;
+  }
+  async client() {
+    if (this.providedClient !== null) return this.providedClient;
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("redis"),
+        { feature: "RedisResource / RedisFileCacheStore", packageName: "redis" }
+      );
+      const c = mod.createClient({
+        url: this.url,
+        socket: { reconnectStrategy: false }
+      });
+      await c.connect();
+      await c.sAdd(this.dk(), "/");
+      return c;
+    })();
+    return this.clientPromise;
+  }
+  async getFile(path) {
+    const c = await this.client();
+    const typed = c;
+    const mod = await import("redis");
+    const blob = mod.RESP_TYPES.BLOB_STRING;
+    const mapping = { [blob]: Buffer };
+    const raw = await typed.withTypeMapping(mapping).get(this.fk(path));
+    if (raw === null) return null;
+    return new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+  }
+  async setFile(path, data) {
+    const c = await this.client();
+    await c.set(this.fk(path), Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+  }
+  async delFile(path) {
+    const c = await this.client();
+    await c.del(this.fk(path));
+  }
+  async hasFile(path) {
+    const c = await this.client();
+    return await c.exists(this.fk(path)) > 0;
+  }
+  async listFiles(prefix = "") {
+    const c = await this.client();
+    const pattern = `${this.keyPrefix}file:${prefix}*`;
+    const strip = `${this.keyPrefix}file:`.length;
+    const result = [];
+    for await (const k of c.scanIterator({ MATCH: pattern })) {
+      const keys = Array.isArray(k) ? k : [k];
+      for (const key of keys) result.push(key.slice(strip));
+    }
+    return result.sort();
+  }
+  async fileLen(path) {
+    const c = await this.client();
+    return c.strLen(this.fk(path));
+  }
+  async hasDir(path) {
+    const c = await this.client();
+    return await c.sIsMember(this.dk(), path) === 1;
+  }
+  async addDir(path) {
+    const c = await this.client();
+    await c.sAdd(this.dk(), path);
+  }
+  async removeDir(path) {
+    const c = await this.client();
+    await c.sRem(this.dk(), path);
+  }
+  async listDirs() {
+    const c = await this.client();
+    const members = await c.sMembers(this.dk());
+    return new Set(members);
+  }
+  async getModified(path) {
+    const c = await this.client();
+    return c.get(this.mk(path));
+  }
+  async setModified(path, ts) {
+    const c = await this.client();
+    await c.set(this.mk(path), ts);
+  }
+  async delModified(path) {
+    const c = await this.client();
+    await c.del(this.mk(path));
+  }
+  async getAttrs(path) {
+    const c = await this.client();
+    const raw = await c.hGetAll(this.ak(path));
+    return { ...raw };
+  }
+  async setAttrs(path, fields) {
+    const c = await this.client();
+    await c.hSet(this.ak(path), fields);
+  }
+  async delAttrs(path) {
+    const c = await this.client();
+    await c.del(this.ak(path));
+  }
+  async clear() {
+    const c = await this.client();
+    for (const pattern of [
+      `${this.keyPrefix}file:*`,
+      `${this.keyPrefix}modified:*`,
+      `${this.keyPrefix}attrs:*`
+    ]) {
+      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);
+    }
+    await c.del(this.dk());
+  }
+  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;
+  }
+};
+
+// src/resource/redis/redis.ts
+var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
+var RedisResource = class extends BaseResource {
+  kind = ResourceName7.REDIS;
+  cachesReads = false;
+  indexTtl = 0;
+  prompt = REDIS_PROMPT;
+  url;
+  keyPrefix;
+  store;
+  accessor;
+  opsMap = {
+    read_bytes: read,
+    write: writeBytes,
+    readdir,
+    stat,
+    unlink,
+    rmdir,
+    copy,
+    rename,
+    mkdir,
+    read_stream: stream,
+    rm_recursive: rmR,
+    du_total: du,
+    du_all: duAll,
+    create,
+    truncate,
+    exists,
+    find_flat: find,
+    append: appendBytes
+  };
+  constructor(options = {}) {
+    super();
+    this.url = options.url ?? "redis://localhost:6379/0";
+    this.keyPrefix = options.keyPrefix ?? "mirage:fs:";
+    this.store = new RedisStore({ url: this.url, keyPrefix: this.keyPrefix });
+    this.accessor = new RedisAccessor(this.store);
+  }
+  async open() {
+    await this.store.client();
+  }
+  close() {
+    return this.store.close();
+  }
+  client() {
+    return this.store.client();
+  }
+  module() {
+    return import("redis");
+  }
+  ops() {
+    return REDIS_OPS;
+  }
+  commands() {
+    return REDIS_COMMANDS;
+  }
+  streamPath(p) {
+    return stream(this.accessor, p);
+  }
+  readFile(p) {
+    return read(this.accessor, p);
+  }
+  writeFile(p, data) {
+    return writeBytes(this.accessor, p, data);
+  }
+  appendFile(p, data) {
+    return appendBytes(this.accessor, p, data);
+  }
+  readdir(p) {
+    return readdir(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return stat(this.accessor, p);
+  }
+  exists(p) {
+    return exists(this.accessor, p);
+  }
+  mkdir(p, options) {
+    return mkdir(this.accessor, p, options?.recursive === true);
+  }
+  rmdir(p) {
+    return rmdir(this.accessor, p);
+  }
+  unlink(p) {
+    return unlink(this.accessor, p);
+  }
+  rename(src, dst) {
+    return rename(this.accessor, src, dst);
+  }
+  truncate(p, length) {
+    return truncate(this.accessor, p, length);
+  }
+  copy(src, dst) {
+    return copy(this.accessor, src, dst);
+  }
+  rmR(p) {
+    return rmR(this.accessor, p);
+  }
+  du(p) {
+    return du(this.accessor, p);
+  }
+  find(p, options = {}) {
+    return find(this.accessor, p, options);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix ? paths.map(
+      (p) => mountPrefixOf2(p.virtual, p.resourcePath) ? p : new PathSpec({
+        virtual: p.virtual,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        resourcePath: mountKey(p.virtual, prefix)
+      })
+    ) : paths;
+    return globCore(this.accessor, effective, this.index);
+  }
+  async getState() {
+    const files = {};
+    for (const key of await this.store.listFiles()) {
+      const data = await this.store.getFile(key);
+      if (data !== null) files[key] = data;
+    }
+    const dirs = [...await this.store.listDirs()].sort();
+    const c = await this.store.client();
+    const attrs = {};
+    const attrsStrip = `${this.keyPrefix}attrs:`.length;
+    for await (const key of c.scanIterator({ MATCH: `${this.keyPrefix}attrs:*` })) {
+      for (const k of Array.isArray(key) ? key : [key]) {
+        attrs[k.slice(attrsStrip)] = { ...await c.hGetAll(k) };
+      }
+    }
+    const modified = {};
+    const modStrip = `${this.keyPrefix}modified:`.length;
+    for await (const key of c.scanIterator({ MATCH: `${this.keyPrefix}modified:*` })) {
+      for (const k of Array.isArray(key) ? key : [key]) {
+        const val = await c.get(k);
+        if (val !== null) modified[k.slice(modStrip)] = val;
+      }
+    }
+    return {
+      type: this.kind,
+      config: {
+        url: REDACTED_SECRET,
+        keyPrefix: this.keyPrefix
+      },
+      keyPrefix: this.keyPrefix,
+      files,
+      dirs,
+      attrs,
+      modified
+    };
+  }
+  async loadState(state) {
+    const c = await this.store.client();
+    const pipe = c.multi();
+    const dirKey = `${this.keyPrefix}dir`;
+    for (const [path, data] of Object.entries(state.files)) {
+      pipe.set(
+        `${this.keyPrefix}file:${path}`,
+        Buffer.from(data.buffer, data.byteOffset, data.byteLength)
+      );
+    }
+    for (const dir of state.dirs) {
+      pipe.sAdd(dirKey, dir);
+    }
+    for (const [path, fields] of Object.entries(state.attrs ?? {})) {
+      if (Object.keys(fields).length > 0) {
+        pipe.hSet(`${this.keyPrefix}attrs:${path}`, fields);
+      }
+    }
+    for (const [path, ts] of Object.entries(state.modified ?? {})) {
+      pipe.set(`${this.keyPrefix}modified:${path}`, ts);
+    }
+    await pipe.exec();
+  }
+};
+
+export {
+  stat,
+  REDIS_COMMANDS,
+  RedisAccessor,
+  REDIS_OPS,
+  REDIS_PROMPT,
+  RedisStore,
+  RedisResource
+};
+//# sourceMappingURL=chunk-OSVZKYXS.js.map