@struktoai/mirage-node 0.0.3 → 0.0.4

package/dist/{chunk-IDYHQQOH.js → chunk-OSVZKYXS.js}

@@ -1,13 +1,16 @@
 import {
   loadOptionalPeer
-} from "./chunk-E2ISWXLB.js";
+} from "./chunk-OQKNDS66.js";
 
 // src/resource/redis/redis.ts
 import {
   BaseResource,
-  PathSpec as PathSpec2,
+  PathSpec,
   REDACTED_SECRET,
-  ResourceName as ResourceName21
+  ResourceName as ResourceName7,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf2
 } from "@struktoai/mirage-core";
 
 // src/commands/builtin/redis/index.ts
@@ -30,7 +33,7 @@ function nowIso() {
 // src/core/redis/read.ts
 async function read(accessor, path, _index) {
   const start = performance.now();
-  const p = norm(path.stripPrefix);
+  const p = norm(path.mountPath);
   const data = await accessor.store.getFile(p);
   if (data === null) {
     throw enoent(path);
@@ -46,36 +49,76 @@ import {
   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.stripPrefix);
+  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
+      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)
+      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 } from "@struktoai/mirage-core";
+import { invalidateAfterWrite as invalidateAfterWrite2 } from "@struktoai/mirage-core";
 async function copy(accessor, src, dst) {
-  const s = norm(src.stripPrefix);
-  const d = norm(dst.stripPrefix);
+  const s = norm(src.mountPath);
+  const d = norm(dst.mountPath);
   const store = accessor.store;
   const data = await store.getFile(s);
   if (data === null) {
@@ -83,13 +126,23 @@ async function copy(accessor, src, dst) {
   }
   await store.setFile(d, data);
   await store.setModified(d, nowIso());
-  await invalidateAfterWrite(dst);
+  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.stripPrefix);
+  const p = norm(path.mountPath);
   const store = accessor.store;
   const prefix = rstripSlash(p) + "/";
   let total = 0;
@@ -101,7 +154,7 @@ async function du(accessor, path) {
   return total;
 }
 async function duAll(accessor, path) {
-  const p = norm(path.stripPrefix);
+  const p = norm(path.mountPath);
   const store = accessor.store;
   const prefix = rstripSlash(p) + "/";
   const entries = [];
@@ -118,7 +171,7 @@ async function duAll(accessor, path) {
 
 // src/core/redis/exists.ts
 async function exists(accessor, path) {
-  const p = norm(path.stripPrefix);
+  const p = norm(path.mountPath);
   const store = accessor.store;
   return await store.hasFile(p) || await store.hasDir(p);
 }
@@ -133,8 +186,8 @@ import {
   startBasename
 } from "@struktoai/mirage-core";
 async function find(accessor, path, options = {}) {
-  const p = norm(path.stripPrefix);
-  const startName = startBasename(path.original);
+  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;
@@ -183,12 +236,10 @@ async function find(accessor, path, options = {}) {
       isEmpty = kind === "f" ? await store.fileLen(key) === 0 : !nonempty.has(key);
     }
     if (!keep({ key, name: basename, kind, depth, isEmpty }, tree, options.minDepth)) continue;
-    if (kind === "f" && (options.minSize !== null && options.minSize !== void 0 || options.maxSize !== null && options.maxSize !== void 0)) {
-      const size = await store.fileLen(key);
-      if (options.minSize !== null && options.minSize !== void 0 && size < options.minSize)
-        continue;
-      if (options.maxSize !== null && options.maxSize !== void 0 && size > options.maxSize)
-        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);
   }
@@ -210,10 +261,10 @@ async function find(accessor, path, options = {}) {
 }
 
 // src/core/redis/mkdir.ts
-import { invalidateAfterWrite as invalidateAfterWrite2 } from "@struktoai/mirage-core";
+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.stripPrefix);
+  const p = norm(path.mountPath);
   const store = accessor.store;
   if (parents) {
     const parts = stripSlash(p).split("/");
@@ -227,6 +278,8 @@ async function mkdir(accessor, path, parents = false) {
         await store.setModified(current, now);
       }
     }
+    await invalidateAfterWrite4(p);
+    await invalidateAncestors(path);
     return;
   }
   const par = parent(p);
@@ -235,11 +288,14 @@ async function mkdir(accessor, path, parents = false) {
   }
   await store.addDir(p);
   await store.setModified(p, nowIso());
-  await invalidateAfterWrite2(p);
+  await invalidateAfterWrite4(p);
 }
 
 // src/core/redis/readdir.ts
-import "@struktoai/mirage-core";
+import {
+  mountPrefixOf,
+  rstripSlash as rstripSlash3
+} from "@struktoai/mirage-core";
 import { enotdir } from "@struktoai/mirage-core";
 
 // src/core/redis/entry.ts
@@ -249,7 +305,10 @@ var RedisResourceType = Object.freeze({
   FOLDER: "folder"
 });
 var RedisIndexEntry = class _RedisIndexEntry extends IndexEntry {
-  static file(path, size = 0) {
+  // 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,
@@ -272,9 +331,9 @@ var RedisIndexEntry = class _RedisIndexEntry extends IndexEntry {
 
 // src/core/redis/readdir.ts
 async function readdir(accessor, path, index) {
-  const virtual = path.pattern !== null ? path.directory : path.stripPrefix;
-  const mountPrefix = path.prefix;
-  const virtualKey = mountPrefix + virtual;
+  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) {
@@ -311,61 +370,71 @@ async function readdir(accessor, path, index) {
 }
 
 // src/core/redis/rename.ts
-import { invalidateAfterUnlink, invalidateAfterWrite as invalidateAfterWrite3 } from "@struktoai/mirage-core";
-import { rstripSlash as rstripSlash3 } from "@struktoai/mirage-core";
+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.stripPrefix);
-  const d = norm(dst.stripPrefix);
+  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 invalidateAfterWrite3(d);
+    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);
-    const prefix = rstripSlash3(s) + "/";
-    const dPrefix = rstripSlash3(d) + "/";
+    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 invalidateAfterWrite3(d);
+    await invalidateAfterWrite5(d);
     return;
   }
   throw new Error(`file not found: ${s}`);
 }
 
 // src/core/redis/rm.ts
-import { invalidateAfterUnlink as invalidateAfterUnlink2, rstripSlash as rstripSlash4 } from "@struktoai/mirage-core";
+import { invalidateAfterUnlink as invalidateAfterUnlink2, rstripSlash as rstripSlash5 } from "@struktoai/mirage-core";
 async function rmR(accessor, path) {
-  const p = norm(path.stripPrefix);
+  const p = norm(path.mountPath);
   const store = accessor.store;
-  const prefix = rstripSlash4(p) + "/";
+  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();
@@ -373,20 +442,21 @@ async function rmR(accessor, path) {
     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 rstripSlash5 } from "@struktoai/mirage-core";
+import { invalidateAfterUnlink as invalidateAfterUnlink3, rstripSlash as rstripSlash6 } from "@struktoai/mirage-core";
 async function rmdir(accessor, path) {
-  const p = norm(path.stripPrefix);
+  const p = norm(path.mountPath);
   const store = accessor.store;
   if (!await store.hasDir(p)) {
     throw new Error(`not a directory: ${p}`);
   }
-  const prefix = rstripSlash5(p) + "/";
+  const prefix = rstripSlash6(p) + "/";
   const files = await store.listFiles();
   const dirs = await store.listDirs();
   const candidates = [...files, ...dirs];
@@ -399,39 +469,77 @@ async function rmdir(accessor, path) {
   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 ResourceName2
+  ResourceName as ResourceName3
 } from "@struktoai/mirage-core";
-import { enoent as enoent3 } from "@struktoai/mirage-core";
+import { enoent as enoent4 } from "@struktoai/mirage-core";
 async function* stream(accessor, path, _index) {
-  const p = norm(path.stripPrefix);
+  const p = norm(path.mountPath);
   const data = await accessor.store.getFile(p);
-  if (data === null) throw enoent3(path);
-  const rec = recordStream("read", p, ResourceName2.REDIS);
+  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.stripPrefix);
+  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 ResourceName3, invalidateAfterWrite as invalidateAfterWrite4, record as record2 } from "@struktoai/mirage-core";
+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.stripPrefix);
+  const p = norm(path.mountPath);
   const par = parent(p);
   const store = accessor.store;
   if (par !== "/" && !await store.hasDir(par)) {
@@ -439,12 +547,12 @@ async function writeBytes(accessor, path, data) {
   }
   await store.setFile(p, data);
   await store.setModified(p, nowIso());
-  record2("write", p, ResourceName3.REDIS, data.byteLength, start);
-  await invalidateAfterWrite4(p);
+  record3("write", p, ResourceName4.REDIS, data.byteLength, start);
+  await invalidateAfterWrite7(p);
 }
 
-// src/commands/builtin/redis/ops.ts
-var REDIS_CMD_OPS = {
+// src/commands/builtin/redis/io.ts
+var REDIS_IO = {
   readdir,
   readBytes: read,
   readStream: stream,
@@ -460,6 +568,10 @@ var REDIS_CMD_OPS = {
   rmR,
   rename,
   copy,
+  create,
+  truncate,
+  append: appendBytes,
+  setAttrs,
   find,
   duTotal: du,
   duAll: async (accessor, path) => {
@@ -468,14 +580,6 @@ var REDIS_CMD_OPS = {
   }
 };
 
-// src/commands/builtin/redis/sed.ts
-import { ResourceName as ResourceName4, makeSed } from "@struktoai/mirage-core";
-var REDIS_SED = makeSed({
-  resource: ResourceName4.REDIS,
-  stream: (a, p) => stream(a, p),
-  write: (a, p, d) => writeBytes(a, p, d)
-});
-
 // src/commands/builtin/redis/index.ts
 var REDIS_COMMANDS = [
   ...makeFiletypeCommands({
@@ -483,8 +587,7 @@ var REDIS_COMMANDS = [
     readBytes: read,
     statEntry: stat
   }),
-  ...makeGenericCommands(ResourceName5.REDIS, REDIS_CMD_OPS),
-  ...REDIS_SED
+  ...makeGenericCommands(ResourceName5.REDIS, REDIS_IO)
 ];
 
 // src/accessor/redis.ts
@@ -497,302 +600,12 @@ var RedisAccessor = class extends Accessor {
   }
 };
 
-// src/core/redis/append.ts
-import { ResourceName as ResourceName6, invalidateAfterWrite as invalidateAfterWrite5, record as record3 } from "@struktoai/mirage-core";
-async function appendBytes(accessor, path, data) {
-  const start = performance.now();
-  const p = norm(path.stripPrefix);
-  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());
-  record3("append", p, ResourceName6.REDIS, data.byteLength, start);
-  await invalidateAfterWrite5(p);
-}
-
-// src/core/redis/create.ts
-import { invalidateAfterWrite as invalidateAfterWrite6 } from "@struktoai/mirage-core";
-async function create(accessor, path) {
-  const p = norm(path.stripPrefix);
-  const store = accessor.store;
-  await store.setFile(p, new Uint8Array(0));
-  await store.setModified(p, nowIso());
-  await invalidateAfterWrite6(path);
-}
-
-// src/core/redis/glob.ts
-import { PathSpec } from "@struktoai/mirage-core";
-import { fnmatch } from "@struktoai/mirage-core";
-import { gnuBasename as gnuBasename2 } from "@struktoai/mirage-core";
-async function resolveGlob(accessor, paths, index) {
-  const result = [];
-  for (const p of paths) {
-    if (p.resolved) {
-      result.push(p);
-    } else if (p.pattern !== null) {
-      const dirSpec = new PathSpec({
-        original: p.directory,
-        directory: p.directory,
-        resolved: true,
-        prefix: p.prefix
-      });
-      const entries = await readdir(accessor, dirSpec, index);
-      const matched = [];
-      for (const e of entries) {
-        if (fnmatch(gnuBasename2(e), p.pattern)) {
-          matched.push(
-            new PathSpec({
-              original: e,
-              directory: p.directory,
-              resolved: true,
-              prefix: p.prefix
-            })
-          );
-        }
-      }
-      if (matched.length > SCOPE_ERROR) matched.length = SCOPE_ERROR;
-      result.push(...matched);
-    } else {
-      result.push(p);
-    }
-  }
-  return result;
-}
-
-// src/core/redis/truncate.ts
-import { invalidateAfterWrite as invalidateAfterWrite7 } from "@struktoai/mirage-core";
-async function truncate(accessor, path, length) {
-  const p = norm(path.stripPrefix);
-  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 invalidateAfterWrite7(p);
-}
-
-// src/ops/redis/append.ts
-import { ResourceName as ResourceName7 } from "@struktoai/mirage-core";
-var appendOp = {
-  name: "append",
-  resource: ResourceName7.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const data = args[0];
-    if (!(data instanceof Uint8Array)) {
-      throw new TypeError("append op requires a Uint8Array as the first arg");
-    }
-    return appendBytes(accessor, path, data);
-  }
-};
-
-// src/ops/redis/create.ts
-import { ResourceName as ResourceName8 } from "@struktoai/mirage-core";
-var createOp = {
-  name: "create",
-  resource: ResourceName8.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => {
-    return create(accessor, path);
-  }
-};
-
-// src/ops/redis/mkdir.ts
-import { ResourceName as ResourceName9 } from "@struktoai/mirage-core";
-var mkdirOp = {
-  name: "mkdir",
-  resource: ResourceName9.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const parents = args[0];
-    return mkdir(accessor, path, parents === true);
-  }
-};
-
-// src/ops/redis/read.ts
-import { ResourceName as ResourceName10 } from "@struktoai/mirage-core";
-var readOp = {
-  name: "read",
-  resource: ResourceName10.REDIS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => {
-    return read(accessor, path);
-  }
-};
-
-// src/ops/redis/read_feather.ts
-import {
-  featherCat,
-  ResourceName as ResourceName11
-} from "@struktoai/mirage-core";
-var readFeatherOp = {
-  name: "read",
-  resource: ResourceName11.REDIS,
-  filetype: ".feather",
-  write: false,
-  fn: async (accessor, path, _args, kwargs) => {
-    const raw = await read(accessor, path, kwargs.index);
-    return featherCat(raw);
-  }
-};
-
-// src/ops/redis/read_hdf5.ts
-import {
-  hdf5Cat,
-  ResourceName as ResourceName12
-} from "@struktoai/mirage-core";
-var readHdf5Op = {
-  name: "read",
-  resource: ResourceName12.REDIS,
-  filetype: ".hdf5",
-  write: false,
-  fn: async (accessor, path, _args, kwargs) => {
-    const raw = await read(accessor, path, kwargs.index);
-    return hdf5Cat(raw);
-  }
-};
-
-// src/ops/redis/read_parquet.ts
-import {
-  parquetCat,
-  ResourceName as ResourceName13
-} from "@struktoai/mirage-core";
-var readParquetOp = {
-  name: "read",
-  resource: ResourceName13.REDIS,
-  filetype: ".parquet",
-  write: false,
-  fn: async (accessor, path, _args, kwargs) => {
-    const raw = await read(accessor, path, kwargs.index);
-    return parquetCat(raw);
-  }
-};
-
-// src/ops/redis/readdir.ts
-import { ResourceName as ResourceName14 } from "@struktoai/mirage-core";
-var readdirOp = {
-  name: "readdir",
-  resource: ResourceName14.REDIS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => {
-    return readdir(accessor, path);
-  }
-};
-
-// src/ops/redis/rename.ts
-import { ResourceName as ResourceName15 } from "@struktoai/mirage-core";
-var renameOp = {
-  name: "rename",
-  resource: ResourceName15.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const dst = args[0];
-    if (dst === void 0 || dst === null || typeof dst !== "object" || !("original" in dst)) {
-      throw new TypeError("rename op requires a PathSpec destination as the first arg");
-    }
-    return rename(accessor, path, dst);
-  }
-};
-
-// src/ops/redis/rmdir.ts
-import { ResourceName as ResourceName16 } from "@struktoai/mirage-core";
-var rmdirOp = {
-  name: "rmdir",
-  resource: ResourceName16.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => {
-    return rmdir(accessor, path);
-  }
-};
-
-// src/ops/redis/stat.ts
-import { ResourceName as ResourceName17 } from "@struktoai/mirage-core";
-var statOp = {
-  name: "stat",
-  resource: ResourceName17.REDIS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => {
-    return stat(accessor, path);
-  }
-};
-
-// src/ops/redis/truncate.ts
-import { ResourceName as ResourceName18 } from "@struktoai/mirage-core";
-var truncateOp = {
-  name: "truncate",
-  resource: ResourceName18.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const length = args[0];
-    if (typeof length !== "number") {
-      throw new TypeError("truncate op requires a number length as the first arg");
-    }
-    return truncate(accessor, path, length);
-  }
-};
-
-// src/ops/redis/unlink.ts
-import { ResourceName as ResourceName19 } from "@struktoai/mirage-core";
-var unlinkOp = {
-  name: "unlink",
-  resource: ResourceName19.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => {
-    return unlink(accessor, path);
-  }
-};
-
-// src/ops/redis/write.ts
-import { extractWriteData } from "@struktoai/mirage-core";
-import { ResourceName as ResourceName20 } from "@struktoai/mirage-core";
-var writeOp = {
-  name: "write",
-  resource: ResourceName20.REDIS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const data = extractWriteData(args);
-    return writeBytes(accessor, path, data);
-  }
-};
-
 // src/ops/redis/index.ts
-var REDIS_OPS = [
-  appendOp,
-  createOp,
-  mkdirOp,
-  readOp,
-  readFeatherOp,
-  readHdf5Op,
-  readParquetOp,
-  readdirOp,
-  renameOp,
-  rmdirOp,
-  statOp,
-  truncateOp,
-  unlinkOp,
-  writeOp
-];
+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.
@@ -818,6 +631,9 @@ var RedisStore = class {
   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 () => {
@@ -872,15 +688,6 @@ var RedisStore = class {
     const c = await this.client();
     return c.strLen(this.fk(path));
   }
-  async getRange(path, start, end) {
-    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).getRange(this.fk(path), start, end);
-    return new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
-  }
   async hasDir(path) {
     const c = await this.client();
     return await c.sIsMember(this.dk(), path) === 1;
@@ -910,9 +717,26 @@ var RedisStore = class {
     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:*`]) {
+    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);
@@ -934,8 +758,9 @@ var RedisStore = class {
 };
 
 // src/resource/redis/redis.ts
+var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
 var RedisResource = class extends BaseResource {
-  kind = ResourceName21.REDIS;
+  kind = ResourceName7.REDIS;
   cachesReads = false;
   indexTtl = 0;
   prompt = REDIS_PROMPT;
@@ -1038,15 +863,15 @@ var RedisResource = class extends BaseResource {
   }
   glob(paths, prefix = "") {
     const effective = prefix ? paths.map(
-      (p) => p.prefix ? p : new PathSpec2({
-        original: p.original,
+      (p) => mountPrefixOf2(p.virtual, p.resourcePath) ? p : new PathSpec({
+        virtual: p.virtual,
         directory: p.directory,
         ...p.pattern !== null ? { pattern: p.pattern } : {},
         resolved: p.resolved,
-        prefix
+        resourcePath: mountKey(p.virtual, prefix)
       })
     ) : paths;
-    return resolveGlob(this.accessor, effective, this.index);
+    return globCore(this.accessor, effective, this.index);
   }
   async getState() {
     const files = {};
@@ -1055,6 +880,22 @@ var RedisResource = class extends BaseResource {
       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: {
@@ -1063,7 +904,9 @@ var RedisResource = class extends BaseResource {
       },
       keyPrefix: this.keyPrefix,
       files,
-      dirs
+      dirs,
+      attrs,
+      modified
     };
   }
   async loadState(state) {
@@ -1079,6 +922,14 @@ var RedisResource = class extends BaseResource {
     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();
   }
 };
@@ -1092,4 +943,4 @@ export {
   RedisStore,
   RedisResource
 };
-//# sourceMappingURL=chunk-IDYHQQOH.js.map
+//# sourceMappingURL=chunk-OSVZKYXS.js.map