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

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

@@ -7,96 +7,59 @@ import {
   BaseResource,
   PathSpec,
   REDACTED_SECRET,
-  ResourceName as ResourceName7,
+  ResourceName as ResourceName9,
   makeResolveGlob,
   mountKey,
-  mountPrefixOf as mountPrefixOf2
+  mountPrefixOf as mountPrefixOf2,
+  stripSlash as stripSlash2,
+  compareCodePoints as compareCodePoints5
 } 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();
-}
+import { ResourceName as ResourceName7, makeGenericCommands } from "@struktoai/mirage-core";
 
-// 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/append.ts
+import { ResourceName, invalidateAfterWrite, record } from "@struktoai/mirage-core";
 
-// src/core/redis/stat.ts
+// src/core/redis/dest.ts
 import {
-  FileStat,
-  FileType,
-  guessType
+  ancestors,
+  eexist,
+  enoent,
+  enotdir,
+  mountedPath
 } 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;
+async function checkDestParents(store, dst, d) {
+  for (const ancestor of ancestors(d)) {
+    if (await store.hasDir(ancestor)) continue;
+    if (await store.hasFile(ancestor)) throw enotdir(dst);
+    throw enoent(dst);
   }
-  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
-    });
+async function checkMkdirTarget(store, spec, key, parents) {
+  if (!parents) {
+    if (await store.hasDir(key) || await store.hasFile(key)) throw eexist(spec);
+    return;
   }
-  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
-    });
+  for (const component of [...ancestors(key), key]) {
+    if (!await store.hasFile(component)) continue;
+    const named = mountedPath(spec, component);
+    throw component === key ? eexist(named) : enotdir(named);
   }
-  throw enoent2(path);
+}
+
+// src/core/redis/utils.ts
+import { norm, gnuBasename } from "@struktoai/mirage-core";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
 }
 
 // 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;
+  await checkDestParents(store, path, p);
   const existing = await store.getFile(p);
   if (existing !== null) {
     const merged = new Uint8Array(existing.byteLength + data.byteLength);
@@ -107,7 +70,7 @@ async function appendBytes(accessor, path, data) {
     await store.setFile(p, data);
   }
   await store.setModified(p, nowIso());
-  record2("append", p, ResourceName2.REDIS, data.byteLength, start);
+  record("append", p, ResourceName.REDIS, data.byteLength, start);
   await invalidateAfterWrite(p);
 }
 
@@ -115,58 +78,63 @@ async function appendBytes(accessor, path, data) {
 var SCOPE_ERROR = 5e4;
 
 // src/core/redis/copy.ts
-import { invalidateAfterWrite as invalidateAfterWrite2 } from "@struktoai/mirage-core";
+import { enoent as enoent2, 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;
+  await checkDestParents(store, dst, d);
   const data = await store.getFile(s);
-  if (data === null) {
-    throw new Error(`file not found: ${s}`);
-  }
+  if (data === null) throw enoent2(src);
   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";
+import { ResourceName as ResourceName2, invalidateAfterWrite as invalidateAfterWrite3, record as record2 } from "@struktoai/mirage-core";
 async function create(accessor, path) {
+  const start = performance.now();
   const p = norm(path.mountPath);
   const store = accessor.store;
+  await checkDestParents(store, path, p);
   await store.setFile(p, new Uint8Array(0));
   await store.setModified(p, nowIso());
+  record2("create", p, ResourceName2.REDIS, 0, start);
   await invalidateAfterWrite3(path);
 }
 
-// src/core/redis/du.ts
-import { rstripSlash } from "@struktoai/mirage-core";
-async function du(accessor, path) {
+// src/core/redis/du/entries.ts
+import { compareCodePoints, rstripSlash } from "@struktoai/mirage-core";
+async function entries(accessor, path) {
   const p = norm(path.mountPath);
   const store = accessor.store;
   const prefix = rstripSlash(p) + "/";
+  const found = [];
   let total = 0;
-  for (const key of await store.listFiles()) {
+  for (const key of [...await store.listFiles()].sort(compareCodePoints)) {
     if (key === p || key.startsWith(prefix)) {
-      total += await store.fileLen(key);
+      const size2 = await store.fileLen(key);
+      found.push([key, size2]);
+      total += size2;
     }
   }
-  return total;
+  return [found, total];
 }
-async function duAll(accessor, path) {
+
+// src/core/redis/du/size.ts
+import { rstripSlash as rstripSlash2 } from "@struktoai/mirage-core";
+async function size(accessor, path) {
   const p = norm(path.mountPath);
   const store = accessor.store;
-  const prefix = rstripSlash(p) + "/";
-  const entries = [];
+  const prefix = rstripSlash2(p) + "/";
   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;
+      total += await store.fileLen(key);
     }
   }
-  return { entries, total };
+  return total;
 }
 
 // src/core/redis/exists.ts
@@ -182,14 +150,15 @@ import {
   computeNonemptyDirs,
   emitStartPath,
   keep,
-  rstripSlash as rstripSlash2,
-  startBasename
+  rstripSlash as rstripSlash3,
+  startBasename,
+  compareCodePoints as compareCodePoints2
 } 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 prefix = rstripSlash3(p) + "/";
   const baseDepth = p === "/" ? 0 : (p.match(/\//g) ?? []).length;
   const results = [];
   const tree = options.tree ?? buildTree({
@@ -237,9 +206,9 @@ async function find(accessor, path, options = {}) {
     }
     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;
+      const size2 = kind === "f" ? await store.fileLen(key) : 0;
+      if (options.minSize != null && size2 < options.minSize) continue;
+      if (options.maxSize != null && size2 > options.maxSize) continue;
     }
     results.push(key);
   }
@@ -256,7 +225,7 @@ async function find(accessor, path, options = {}) {
       maxSize: options.maxSize
     });
   }
-  results.sort();
+  results.sort(compareCodePoints2);
   return results;
 }
 
@@ -266,6 +235,7 @@ import { stripSlash } from "@struktoai/mirage-core";
 async function mkdir(accessor, path, parents = false) {
   const p = norm(path.mountPath);
   const store = accessor.store;
+  await checkMkdirTarget(store, path, p, parents);
   if (parents) {
     const parts = stripSlash(p).split("/");
     let current = "";
@@ -282,21 +252,33 @@ async function mkdir(accessor, path, parents = false) {
     await invalidateAncestors(path);
     return;
   }
-  const par = parent(p);
-  if (par !== "/" && !await store.hasDir(par)) {
-    throw new Error(`parent directory does not exist: ${par}`);
-  }
+  await checkDestParents(store, path, p);
   await store.addDir(p);
   await store.setModified(p, nowIso());
   await invalidateAfterWrite4(p);
 }
 
+// src/core/redis/read.ts
+import { record as record3, ResourceName as ResourceName3 } from "@struktoai/mirage-core";
+import { enoent as enoent3 } from "@struktoai/mirage-core";
+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 enoent3(path);
+  }
+  record3("read", p, ResourceName3.REDIS, data.byteLength, start);
+  return data;
+}
+
 // src/core/redis/readdir.ts
 import {
   mountPrefixOf,
-  rstripSlash as rstripSlash3
+  rstripSlash as rstripSlash4,
+  compareCodePoints as compareCodePoints3
 } from "@struktoai/mirage-core";
-import { enotdir } from "@struktoai/mirage-core";
+import { readdirError } from "@struktoai/mirage-core";
 
 // src/core/redis/entry.ts
 import { IndexEntry } from "@struktoai/mirage-core";
@@ -308,14 +290,14 @@ 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) {
+  static file(path, size2 = null) {
     const name = path.slice(path.lastIndexOf("/") + 1);
     return new _RedisIndexEntry({
       id: path,
       name,
       resourceType: RedisResourceType.FILE,
       vfsName: name,
-      size
+      size: size2
     });
   }
   static folder(path) {
@@ -333,7 +315,7 @@ var RedisIndexEntry = class _RedisIndexEntry extends IndexEntry {
 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) || "/";
+  const virtualKey = rstripSlash4(mountPrefix + virtual) || "/";
   if (index !== void 0) {
     const cached = await index.listDir(virtualKey);
     if (cached.entries !== void 0 && cached.entries !== null) {
@@ -343,7 +325,12 @@ async function readdir(accessor, path, index) {
   const store = accessor.store;
   const p = norm(virtual);
   if (!await store.hasDir(p)) {
-    throw enotdir(path);
+    throw await readdirError(
+      path,
+      p,
+      (k) => store.hasFile(k),
+      (k) => store.hasDir(k)
+    );
   }
   const dirPrefix = p === "/" ? "/" : `${p}/`;
   const seen = /* @__PURE__ */ new Set();
@@ -356,32 +343,33 @@ async function readdir(accessor, path, index) {
     const first = remainder.split("/")[0];
     if (first !== void 0 && first.length > 0) seen.add(dirPrefix + first);
   }
-  const sorted = [...seen].sort();
+  const sorted = [...seen].sort(compareCodePoints3);
   const virtualEntries = sorted.map((entry) => `${mountPrefix}${entry}`);
   if (index !== void 0) {
     const fileSet = new Set(files);
-    const entries = sorted.map((e) => {
+    const entries2 = 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);
+    await index.setDir(virtualKey, entries2);
   }
   return virtualEntries;
 }
 
 // src/core/redis/rename.ts
 import { invalidateAfterUnlink, invalidateAfterWrite as invalidateAfterWrite5 } from "@struktoai/mirage-core";
-import { rstripSlash as rstripSlash4 } from "@struktoai/mirage-core";
+import { enoent as enoent4, rstripSlash as rstripSlash5 } 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;
+  await checkDestParents(store, dst, d);
   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}`);
+    if (data === null) throw enoent4(src);
     await store.delFile(s);
     await store.delModified(s);
     await store.delAttrs(s);
@@ -401,8 +389,8 @@ async function rename(accessor, src, dst) {
     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 prefix = rstripSlash5(s) + "/";
+    const dPrefix = rstripSlash5(d) + "/";
     const files = await store.listFiles();
     for (const key of files) {
       if (key.startsWith(prefix)) {
@@ -420,15 +408,15 @@ async function rename(accessor, src, dst) {
     await invalidateAfterWrite5(d);
     return;
   }
-  throw new Error(`file not found: ${s}`);
+  throw enoent4(src);
 }
 
 // src/core/redis/rm.ts
-import { invalidateAfterUnlink as invalidateAfterUnlink2, rstripSlash as rstripSlash5 } from "@struktoai/mirage-core";
+import { invalidateAfterUnlink as invalidateAfterUnlink2, rstripSlash as rstripSlash6 } from "@struktoai/mirage-core";
 async function rmR(accessor, path) {
   const p = norm(path.mountPath);
   const store = accessor.store;
-  const prefix = rstripSlash5(p) + "/";
+  const prefix = rstripSlash6(p) + "/";
   const files = await store.listFiles();
   for (const key of files) {
     if (key === p || key.startsWith(prefix)) {
@@ -449,14 +437,14 @@ async function rmR(accessor, path) {
 }
 
 // src/core/redis/rmdir.ts
-import { invalidateAfterUnlink as invalidateAfterUnlink3, rstripSlash as rstripSlash6 } from "@struktoai/mirage-core";
+import { invalidateAfterUnlink as invalidateAfterUnlink3, rstripSlash as rstripSlash7 } 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 prefix = rstripSlash7(p) + "/";
   const files = await store.listFiles();
   const dirs = await store.listDirs();
   const candidates = [...files, ...dirs];
@@ -470,12 +458,12 @@ async function rmdir(accessor, path) {
 }
 
 // src/core/redis/set_attrs.ts
-import { enoent as enoent3 } from "@struktoai/mirage-core";
+import { enoent as enoent5 } 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);
+    throw enoent5(path);
   }
   const encoded = {};
   if (fields.mode !== void 0) encoded.mode = String(fields.mode);
@@ -491,24 +479,74 @@ async function setAttrs(accessor, path, fields) {
   return {};
 }
 
+// src/core/redis/stat.ts
+import {
+  FileStat,
+  FileType,
+  guessType
+} from "@struktoai/mirage-core";
+import { enoent as enoent6 } 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 size2 = await store.fileLen(p);
+    const attrs = decodeAttrs(await store.getAttrs(p));
+    return new FileStat({
+      name: gnuBasename(p),
+      size: size2,
+      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 enoent6(path);
+}
+
 // src/core/redis/stream.ts
 import {
   recordStream,
-  ResourceName as ResourceName3
+  ResourceName as ResourceName4
 } from "@struktoai/mirage-core";
-import { enoent as enoent4 } from "@struktoai/mirage-core";
+import { enoent as enoent7 } 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 (data === null) throw enoent7(path);
+  const rec = recordStream("read", p, ResourceName4.REDIS);
   if (rec !== null) rec.bytes = data.byteLength;
   yield data;
 }
 
 // src/core/redis/truncate.ts
-import { invalidateAfterWrite as invalidateAfterWrite6 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName5, invalidateAfterWrite as invalidateAfterWrite6, record as record4 } from "@struktoai/mirage-core";
 async function truncate(accessor, path, length) {
+  const start = performance.now();
   const p = norm(path.mountPath);
   const store = accessor.store;
   const existing = await store.getFile(p);
@@ -518,6 +556,7 @@ async function truncate(accessor, path, length) {
   out.set(data.subarray(0, copyLen), 0);
   await store.setFile(p, out);
   await store.setModified(p, nowIso());
+  record4("truncate", p, ResourceName5.REDIS, 0, start);
   await invalidateAfterWrite6(p);
 }
 
@@ -536,18 +575,15 @@ async function unlink(accessor, path) {
 }
 
 // src/core/redis/write.ts
-import { ResourceName as ResourceName4, invalidateAfterWrite as invalidateAfterWrite7, record as record3 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName6, invalidateAfterWrite as invalidateAfterWrite7, record as record5 } 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 checkDestParents(store, path, p);
   await store.setFile(p, data);
   await store.setModified(p, nowIso());
-  record3("write", p, ResourceName4.REDIS, data.byteLength, start);
+  record5("write", p, ResourceName6.REDIS, data.byteLength, start);
   await invalidateAfterWrite7(p);
 }
 
@@ -573,21 +609,12 @@ var REDIS_IO = {
   append: appendBytes,
   setAttrs,
   find,
-  duTotal: du,
-  duAll: async (accessor, path) => {
-    const { entries, total } = await duAll(accessor, path);
-    return [entries, total];
-  }
+  du: { size, entries }
 };
 
 // src/commands/builtin/redis/index.ts
 var REDIS_COMMANDS = [
-  ...makeFiletypeCommands({
-    resource: ResourceName5.REDIS,
-    readBytes: read,
-    statEntry: stat
-  }),
-  ...makeGenericCommands(ResourceName5.REDIS, REDIS_IO)
+  ...makeGenericCommands(ResourceName7.REDIS, REDIS_IO)
 ];
 
 // src/accessor/redis.ts
@@ -601,17 +628,15 @@ var RedisAccessor = class extends Accessor {
 };
 
 // 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
-});
+import { ResourceName as ResourceName8, makeGenericOps } from "@struktoai/mirage-core";
+var REDIS_OPS = makeGenericOps(ResourceName8.REDIS, REDIS_IO);
 
 // 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
+import { compareCodePoints as compareCodePoints4 } from "@struktoai/mirage-core";
 var RedisStore = class {
   url;
   keyPrefix;
@@ -682,7 +707,7 @@ var RedisStore = class {
       const keys = Array.isArray(k) ? k : [k];
       for (const key of keys) result.push(key.slice(strip));
     }
-    return result.sort();
+    return result.sort(compareCodePoints4);
   }
   async fileLen(path) {
     const c = await this.client();
@@ -760,8 +785,10 @@ var RedisStore = class {
 // src/resource/redis/redis.ts
 var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
 var RedisResource = class extends BaseResource {
-  kind = ResourceName7.REDIS;
+  kind = ResourceName9.REDIS;
   cachesReads = false;
+  // byte store: stat() sizes every file from metadata
+  sizesAlwaysKnown = true;
   indexTtl = 0;
   prompt = REDIS_PROMPT;
   url;
@@ -780,8 +807,8 @@ var RedisResource = class extends BaseResource {
     mkdir,
     read_stream: stream,
     rm_recursive: rmR,
-    du_total: du,
-    du_all: duAll,
+    du_size: size,
+    du_entries: entries,
     create,
     truncate,
     exists,
@@ -795,11 +822,20 @@ var RedisResource = class extends BaseResource {
     this.store = new RedisStore({ url: this.url, keyPrefix: this.keyPrefix });
     this.accessor = new RedisAccessor(this.store);
   }
+  // The server URL (host, port and db) plus the key prefix pin the keyspace
+  // two mounts would share. The prefix is joined path-like so nested
+  // prefixes collapse onto one key.
+  storageId() {
+    const prefix = stripSlash2(this.keyPrefix);
+    const base = `${this.kind}:${this.url}`;
+    return prefix === "" ? base : `${base}/${prefix}`;
+  }
   async open() {
     await this.store.client();
   }
-  close() {
-    return this.store.close();
+  async close() {
+    await this.store.close();
+    await super.close();
   }
   client() {
     return this.store.client();
@@ -856,7 +892,7 @@ var RedisResource = class extends BaseResource {
     return rmR(this.accessor, p);
   }
   du(p) {
-    return du(this.accessor, p);
+    return size(this.accessor, p);
   }
   find(p, options = {}) {
     return find(this.accessor, p, options);
@@ -879,7 +915,7 @@ var RedisResource = class extends BaseResource {
       const data = await this.store.getFile(key);
       if (data !== null) files[key] = data;
     }
-    const dirs = [...await this.store.listDirs()].sort();
+    const dirs = [...await this.store.listDirs()].sort(compareCodePoints5);
     const c = await this.store.client();
     const attrs = {};
     const attrsStrip = `${this.keyPrefix}attrs:`.length;
@@ -943,4 +979,4 @@ export {
   RedisStore,
   RedisResource
 };
-//# sourceMappingURL=chunk-OSVZKYXS.js.map
+//# sourceMappingURL=chunk-HOPUP6LA.js.map