@struktoai/mirage-node 0.0.4 → 0.0.5

package/dist/{chunk-CGGO5NKD.js → chunk-YUJBXFYK.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-OQKNDS66.js";
 import {
   redactConfig
-} from "./chunk-C7TNKIK5.js";
+} from "./chunk-CTGXJHO5.js";
 
 // src/resource/gridfs/gridfs.ts
 import {
   BaseResource,
   PathSpec,
-  ResourceName as ResourceName12,
+  ResourceName as ResourceName13,
   makeResolveGlob,
   mountKey,
   mountPrefixOf as mountPrefixOf4,
@@ -52,18 +52,20 @@ var GridFSAccessor = class extends Accessor {
 
 // src/commands/builtin/gridfs/index.ts
 import {
-  ResourceName as ResourceName10,
-  makeFiletypeCommands,
-  makeGenericCommands
+  ResourceName as ResourceName11,
+  makeGenericCommands,
+  resolveGlobOf as resolveGlobOf6,
+  withDefaultProvisions
 } from "@struktoai/mirage-core";
 
-// src/core/gridfs/read.ts
-import {
-  ResourceName,
-  enoent,
-  record,
-  revisionFor
-} from "@struktoai/mirage-core";
+// src/commands/builtin/gridfs/io.ts
+import { rangeOf } from "@struktoai/mirage-core";
+
+// src/core/gridfs/constants.ts
+var SCOPE_ERROR = 5e3;
+
+// src/core/gridfs/copy.ts
+import { enoent, invalidateAfterWrite } from "@struktoai/mirage-core";
 
 // src/core/gridfs/_client.ts
 import { keyPrefix as kp, mountPrefixOf } from "@struktoai/mirage-core";
@@ -166,70 +168,101 @@ async function deleteAll(accessor, query) {
   }
 }
 
-// src/core/gridfs/read.ts
-async function resolveFileId(accessor, path, key) {
-  const pinnedRevision = revisionFor(path.virtual);
-  if (pinnedRevision !== null) {
-    const mod = await loadGridFSModule();
-    const objectIdCtor = mod.ObjectId;
-    return new objectIdCtor(pinnedRevision);
-  }
-  const doc = await latestFile(accessor, key);
-  if (doc === null) throw enoent(path);
-  return doc._id;
-}
-async function downloadBytes(accessor, path, fileId, options = {}) {
+// src/core/gridfs/copy.ts
+async function copy(accessor, src, dst) {
+  const srcKey = gridfsKey(rawPathOf(src), accessor.config);
+  const dstKey = gridfsKey(rawPathOf(dst), accessor.config);
+  const doc = await latestFile(accessor, srcKey);
+  if (doc === null) throw enoent(src);
   const b = await bucket(accessor);
-  const streamOptions = {};
-  if (options.offset !== void 0 && options.offset !== 0) {
-    streamOptions.start = options.offset;
-  }
-  if (options.size !== void 0) {
-    streamOptions.end = (options.offset ?? 0) + options.size;
-  }
-  const readable = b.openDownloadStream(
-    fileId,
-    Object.keys(streamOptions).length > 0 ? streamOptions : void 0
-  );
-  const chunks = [];
-  let total = 0;
-  try {
-    for await (const chunk of readable) {
-      chunks.push(chunk);
-      total += chunk.byteLength;
-    }
-  } catch (err) {
-    if (err?.code === "ENOENT" || isNoFileError(err)) {
-      throw enoent(path);
-    }
-    throw err;
-  }
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const c of chunks) {
-    out.set(c, offset);
-    offset += c.byteLength;
-  }
-  return out;
+  const readable = b.openDownloadStream(doc._id);
+  const upload = b.openUploadStream(dstKey);
+  await new Promise((resolve, reject) => {
+    upload.on("error", reject);
+    readable.on("error", reject);
+    upload.on("finish", () => {
+      resolve();
+    });
+    readable.pipe(upload);
+  });
+  await invalidateAfterWrite(dst);
 }
-function isNoFileError(err) {
-  if (err === null || typeof err !== "object") return false;
-  const message = err.message ?? "";
-  return message.includes("FileNotFound");
+
+// src/core/gridfs/create.ts
+import { ResourceName as ResourceName2, invalidateAfterWrite as invalidateAfterWrite3, record as record2 } from "@struktoai/mirage-core";
+
+// src/core/gridfs/write.ts
+import {
+  ResourceName,
+  invalidateAfterWrite as invalidateAfterWrite2,
+  invalidateAncestors,
+  record
+} from "@struktoai/mirage-core";
+async function uploadBytes(accessor, key, data) {
+  const b = await bucket(accessor);
+  const upload = b.openUploadStream(key);
+  await new Promise((resolve, reject) => {
+    upload.on("error", reject);
+    upload.on("finish", () => {
+      resolve();
+    });
+    upload.end(data);
+  });
 }
-async function read(accessor, path, _index, options = {}) {
-  const virtual = path.virtual;
+async function write(accessor, path, data) {
   const raw = rawPathOf(path);
   const key = gridfsKey(raw, accessor.config);
   const startMs = performance.now();
-  const fileId = await resolveFileId(accessor, path, key);
-  const bytes = await downloadBytes(accessor, path, fileId, options);
-  const revision = fileId.toString();
-  record("read", virtual, ResourceName.GRIDFS, bytes.byteLength, startMs, {
-    fingerprint: revision,
-    revision
-  });
-  return bytes;
+  await uploadBytes(accessor, key, data);
+  record("write", path.virtual, ResourceName.GRIDFS, data.byteLength, startMs);
+  await invalidateAfterWrite2(path);
+  await invalidateAncestors(path);
+}
+
+// src/core/gridfs/create.ts
+async function create(accessor, path) {
+  const raw = rawPathOf(path);
+  const startMs = performance.now();
+  await uploadBytes(accessor, gridfsKey(raw, accessor.config), new Uint8Array(0));
+  record2("create", path.virtual, ResourceName2.GRIDFS, 0, startMs);
+  await invalidateAfterWrite3(path);
+}
+
+// src/core/gridfs/du/entries.ts
+import { rstripSlash } from "@struktoai/mirage-core";
+
+// src/core/gridfs/du/walk.ts
+function duQuery(stem) {
+  if (stem === "") return {};
+  return {
+    $or: [{ filename: stem }, { filename: { $regex: `^${escapeRegex(stem + "/")}` } }]
+  };
+}
+
+// src/core/gridfs/du/entries.ts
+async function entries(accessor, path) {
+  const raw = rawPathOf(path);
+  const stem = rstripSlash(gridfsKey(raw, accessor.config));
+  const entries2 = [];
+  let total = 0;
+  for await (const doc of iterLatest(accessor, duQuery(stem))) {
+    const entry = "/" + stripKeyPrefix(doc.filename, accessor.config);
+    entries2.push([entry, doc.length]);
+    total += doc.length;
+  }
+  return [entries2, total];
+}
+
+// src/core/gridfs/du/size.ts
+import { rstripSlash as rstripSlash2 } from "@struktoai/mirage-core";
+async function size(accessor, path) {
+  const raw = rawPathOf(path);
+  const stem = rstripSlash2(gridfsKey(raw, accessor.config));
+  let total = 0;
+  for await (const doc of iterLatest(accessor, duQuery(stem))) {
+    total += doc.length;
+  }
+  return total;
 }
 
 // src/core/gridfs/stat.ts
@@ -240,7 +273,7 @@ import {
   gnuBasename,
   guessType,
   mountPrefixOf as mountPrefixOf2,
-  rstripSlash,
+  rstripSlash as rstripSlash3,
   stripSlash
 } from "@struktoai/mirage-core";
 async function stat(accessor, path, index) {
@@ -290,7 +323,7 @@ async function stat(accessor, path, index) {
       });
     }
   }
-  const pfx = rstripSlash(key) + "/";
+  const pfx = rstripSlash3(key) + "/";
   const files = await filesColl(accessor);
   const probe = await files.findOne(
     { filename: { $regex: `^${escapeRegex(pfx)}` } },
@@ -302,102 +335,6 @@ async function stat(accessor, path, index) {
   throw enoent2(path);
 }
 
-// src/commands/builtin/gridfs/du.ts
-import {
-  ResourceName as ResourceName4,
-  command,
-  duGeneric,
-  metadataProvision,
-  resolveGlobOf,
-  specOf
-} from "@struktoai/mirage-core";
-
-// src/core/gridfs/du.ts
-import { rstripSlash as rstripSlash2 } from "@struktoai/mirage-core";
-function duQuery(stem) {
-  if (stem === "") return {};
-  return {
-    $or: [{ filename: stem }, { filename: { $regex: `^${escapeRegex(stem + "/")}` } }]
-  };
-}
-async function du(accessor, path) {
-  const raw = rawPathOf(path);
-  const stem = rstripSlash2(gridfsKey(raw, accessor.config));
-  let total = 0;
-  for await (const doc of iterLatest(accessor, duQuery(stem))) {
-    total += doc.length;
-  }
-  return total;
-}
-async function duAll(accessor, path) {
-  const raw = rawPathOf(path);
-  const stem = rstripSlash2(gridfsKey(raw, accessor.config));
-  const entries = [];
-  let total = 0;
-  for await (const doc of iterLatest(accessor, duQuery(stem))) {
-    const entry = "/" + stripKeyPrefix(doc.filename, accessor.config);
-    entries.push([entry, doc.length]);
-    total += doc.length;
-  }
-  return [entries, total];
-}
-
-// src/core/gridfs/constants.ts
-var SCOPE_ERROR = 5e3;
-
-// src/core/gridfs/copy.ts
-import { enoent as enoent3, invalidateAfterWrite } from "@struktoai/mirage-core";
-async function copy(accessor, src, dst) {
-  const srcKey = gridfsKey(rawPathOf(src), accessor.config);
-  const dstKey = gridfsKey(rawPathOf(dst), accessor.config);
-  const doc = await latestFile(accessor, srcKey);
-  if (doc === null) throw enoent3(src);
-  const b = await bucket(accessor);
-  const readable = b.openDownloadStream(doc._id);
-  const upload = b.openUploadStream(dstKey);
-  await new Promise((resolve, reject) => {
-    upload.on("error", reject);
-    readable.on("error", reject);
-    upload.on("finish", () => {
-      resolve();
-    });
-    readable.pipe(upload);
-  });
-  await invalidateAfterWrite(dst);
-}
-
-// src/core/gridfs/create.ts
-import { invalidateAfterWrite as invalidateAfterWrite3 } from "@struktoai/mirage-core";
-
-// src/core/gridfs/write.ts
-import { ResourceName as ResourceName2, invalidateAfterWrite as invalidateAfterWrite2, record as record2 } from "@struktoai/mirage-core";
-async function uploadBytes(accessor, key, data) {
-  const b = await bucket(accessor);
-  const upload = b.openUploadStream(key);
-  await new Promise((resolve, reject) => {
-    upload.on("error", reject);
-    upload.on("finish", () => {
-      resolve();
-    });
-    upload.end(data);
-  });
-}
-async function write(accessor, path, data) {
-  const raw = rawPathOf(path);
-  const key = gridfsKey(raw, accessor.config);
-  const startMs = performance.now();
-  await uploadBytes(accessor, key, data);
-  record2("write", path.virtual, ResourceName2.GRIDFS, data.byteLength, startMs);
-  await invalidateAfterWrite2(path);
-}
-
-// src/core/gridfs/create.ts
-async function create(accessor, path) {
-  const raw = rawPathOf(path);
-  await uploadBytes(accessor, gridfsKey(raw, accessor.config), new Uint8Array(0));
-  await invalidateAfterWrite3(path);
-}
-
 // src/core/gridfs/exists.ts
 async function exists(accessor, path) {
   try {
@@ -414,8 +351,9 @@ import {
   buildTree,
   emitStartPath,
   keep,
-  rstripSlash as rstripSlash3,
-  startBasename
+  rstripSlash as rstripSlash4,
+  startBasename,
+  compareCodePoints
 } from "@struktoai/mirage-core";
 function globRegex(pattern) {
   if (pattern.includes("[") || pattern.includes("]")) return null;
@@ -465,10 +403,13 @@ async function find(accessor, path, options = {}) {
   const raw = rawPathOf(path);
   const startName = startBasename(path.virtual);
   const pfx = gridfsPrefix(raw, accessor.config);
+  const rootKey = rstripSlash4("/" + stripKeyPrefix(pfx, accessor.config)) || "/";
+  const baseDepth = rootKey === "/" ? 0 : (rootKey.match(/\//g) ?? []).length;
   const results = [];
+  const seenDirs = /* @__PURE__ */ new Set();
   const seen = { descendant: false, marker: false };
   const empty = options.empty === true;
-  const pushdown = options.tree === void 0 && options.nameExclude === void 0 && options.orNames === void 0 && options.pathPattern === void 0 && !empty;
+  const pushdown = options.tree === void 0 && options.nameExclude === void 0 && options.orNames === void 0 && options.pathPattern === void 0 && !empty && options.type === "f";
   const tree = options.tree ?? buildTree({
     name: options.name,
     iname: options.iname,
@@ -487,30 +428,39 @@ async function find(accessor, path, options = {}) {
       continue;
     }
     seen.descendant = true;
-    const relative = key.slice(pfx.length);
-    const depth = (relative.match(/\//g) ?? []).length + 1;
-    if (options.maxDepth !== null && options.maxDepth !== void 0 && depth > options.maxDepth) {
-      continue;
-    }
     const isDir = key.endsWith("/");
-    const normKey = isDir ? key.slice(0, -1) : key;
-    const entryName = normKey.split("/").pop() ?? "";
-    const fullPath = rstripSlash3("/" + stripKeyPrefix(key, accessor.config)) || "/";
-    const size = doc.length;
-    const isEmpty = !empty ? null : isDir ? false : size === 0;
-    if (!keep(
-      { key: fullPath, name: entryName, kind: isDir ? "d" : "f", depth, isEmpty },
-      tree,
-      options.minDepth
-    )) {
-      continue;
+    const fullPath = rstripSlash4("/" + stripKeyPrefix(key, accessor.config)) || "/";
+    const size2 = doc.length;
+    if (isDir) {
+      if (seenDirs.has(fullPath)) continue;
+      seenDirs.add(fullPath);
     }
-    if (options.minSize != null || options.maxSize != null) {
-      const effective = isDir ? 0 : size;
-      if (options.minSize != null && effective < options.minSize) continue;
-      if (options.maxSize != null && effective > options.maxSize) continue;
+    const entries2 = [[fullPath, isDir ? "d" : "f"]];
+    let parent = fullPath.slice(0, fullPath.lastIndexOf("/")) || "/";
+    while (parent !== rootKey && parent !== "/") {
+      if (!seenDirs.has(parent)) {
+        seenDirs.add(parent);
+        entries2.push([parent, "d"]);
+      }
+      parent = parent.slice(0, parent.lastIndexOf("/")) || "/";
+    }
+    for (const [ep, kind] of entries2) {
+      const entryName = ep.split("/").pop() ?? "";
+      const depth = (ep.match(/\//g) ?? []).length - baseDepth;
+      if (options.maxDepth !== null && options.maxDepth !== void 0 && depth > options.maxDepth) {
+        continue;
+      }
+      const isEmpty = !empty ? null : kind === "d" ? false : size2 === 0;
+      if (!keep({ key: ep, name: entryName, kind, depth, isEmpty }, tree, options.minDepth)) {
+        continue;
+      }
+      if (options.minSize != null || options.maxSize != null) {
+        const effective = kind === "d" ? 0 : size2;
+        if (options.minSize != null && effective < options.minSize) continue;
+        if (options.maxSize != null && effective > options.maxSize) continue;
+      }
+      results.push(ep);
     }
-    results.push(fullPath);
   }
   if (narrowed && !seen.descendant && !seen.marker) {
     const files = await filesColl(accessor);
@@ -520,11 +470,10 @@ async function find(accessor, path, options = {}) {
     );
     seen.descendant = probe !== null;
   }
-  const rootKey = rstripSlash3("/" + stripKeyPrefix(pfx, accessor.config)) || "/";
   if (seen.descendant || seen.marker) {
     emitStartPath(results, rootKey, startName, {
       kind: "d",
-      isEmpty: empty ? false : null,
+      isEmpty: empty ? !seen.descendant : null,
       exists: true,
       tree,
       maxDepth: options.maxDepth,
@@ -533,18 +482,90 @@ async function find(accessor, path, options = {}) {
       maxSize: options.maxSize
     });
   }
-  return results.sort();
+  return [...new Set(results)].sort(compareCodePoints);
 }
 
 // src/core/gridfs/mkdir.ts
-import { invalidateAfterWrite as invalidateAfterWrite4, invalidateAncestors } from "@struktoai/mirage-core";
+import { invalidateAfterWrite as invalidateAfterWrite4, invalidateAncestors as invalidateAncestors2 } from "@struktoai/mirage-core";
 async function mkdir(accessor, path, parents = false) {
   const raw = rawPathOf(path);
   const pfx = gridfsPrefix(raw, accessor.config);
   if (pfx === "") return;
   await uploadBytes(accessor, pfx, new Uint8Array(0));
   await invalidateAfterWrite4(path);
-  if (parents) await invalidateAncestors(path);
+  if (parents) await invalidateAncestors2(path);
+}
+
+// src/core/gridfs/read.ts
+import {
+  ResourceName as ResourceName3,
+  enoent as enoent3,
+  record as record3,
+  revisionFor
+} from "@struktoai/mirage-core";
+async function resolveFileId(accessor, path, key) {
+  const pinnedRevision = revisionFor(path.virtual);
+  if (pinnedRevision !== null) {
+    const mod = await loadGridFSModule();
+    const objectIdCtor = mod.ObjectId;
+    return new objectIdCtor(pinnedRevision);
+  }
+  const doc = await latestFile(accessor, key);
+  if (doc === null) throw enoent3(path);
+  return doc._id;
+}
+async function downloadBytes(accessor, path, fileId, options = {}) {
+  const b = await bucket(accessor);
+  const streamOptions = {};
+  if (options.offset !== void 0 && options.offset !== 0) {
+    streamOptions.start = options.offset;
+  }
+  if (options.size !== void 0) {
+    streamOptions.end = (options.offset ?? 0) + options.size;
+  }
+  const readable = b.openDownloadStream(
+    fileId,
+    Object.keys(streamOptions).length > 0 ? streamOptions : void 0
+  );
+  const chunks = [];
+  let total = 0;
+  try {
+    for await (const chunk of readable) {
+      chunks.push(chunk);
+      total += chunk.byteLength;
+    }
+  } catch (err) {
+    if (err?.code === "ENOENT" || isNoFileError(err)) {
+      throw enoent3(path);
+    }
+    throw err;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+function isNoFileError(err) {
+  if (err === null || typeof err !== "object") return false;
+  const message = err.message ?? "";
+  return message.includes("FileNotFound");
+}
+async function read(accessor, path, _index, options = {}) {
+  const virtual = path.virtual;
+  const raw = rawPathOf(path);
+  const key = gridfsKey(raw, accessor.config);
+  const startMs = performance.now();
+  const fileId = await resolveFileId(accessor, path, key);
+  const bytes = await downloadBytes(accessor, path, fileId, options);
+  const revision = fileId.toString();
+  record3("read", virtual, ResourceName3.GRIDFS, bytes.byteLength, startMs, {
+    fingerprint: revision,
+    revision
+  });
+  return bytes;
 }
 
 // src/core/gridfs/readdir.ts
@@ -552,16 +573,17 @@ import {
   IndexEntry,
   ResourceType,
   mountPrefixOf as mountPrefixOf3,
-  rstripSlash as rstripSlash4
+  rstripSlash as rstripSlash5,
+  compareCodePoints as compareCodePoints2
 } from "@struktoai/mirage-core";
 async function readdir(accessor, path, index) {
   const original = path.virtual;
   const prefix = mountPrefixOf3(path.virtual, path.resourcePath);
   const virtual = path.pattern !== null ? path.directory : original;
   const rawPath = prefix !== "" && virtual.startsWith(prefix) ? virtual.slice(prefix.length) || "/" : virtual;
-  const virtualKey = rawPath === "/" ? "/" : rstripSlash4(rawPath) || "/";
+  const virtualKey = rawPath === "/" ? "/" : rstripSlash5(rawPath) || "/";
   const rawFullKey = prefix !== "" ? `${prefix}${virtualKey}` : virtualKey;
-  const fullVirtualKey = rstripSlash4(rawFullKey) || "/";
+  const fullVirtualKey = rstripSlash5(rawFullKey) || "/";
   if (index !== void 0) {
     const listing = await index.listDir(fullVirtualKey);
     if (listing.entries !== void 0 && listing.entries !== null) {
@@ -593,13 +615,13 @@ async function readdir(accessor, path, index) {
       }
     }
   }
-  names.sort();
+  names.sort(compareCodePoints2);
   if (names.length > SCOPE_ERROR) {
     console.warn(
       `gridfs readdir: ${fullVirtualKey} returned ${String(names.length)} entries (limit ${String(SCOPE_ERROR)})`
     );
   }
-  const virtualEntries = names.map((e) => prefix !== "" ? `${prefix}${e}` : e).sort();
+  const virtualEntries = names.map((e) => prefix !== "" ? `${prefix}${e}` : e).sort(compareCodePoints2);
   if (index !== void 0) {
     const indexEntries = names.map((e) => {
       const name = e.split("/").pop() ?? "";
@@ -660,13 +682,13 @@ async function rmdir(accessor, path) {
 }
 
 // src/core/gridfs/stream.ts
-import { ResourceName as ResourceName3, enoent as enoent5, recordStream } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName4, enoent as enoent5, recordStream } from "@struktoai/mirage-core";
 var DEFAULT_CHUNK_SIZE = 8192;
 async function* stream(accessor, path) {
   const virtual = path.virtual;
   const raw = rawPathOf(path);
   const key = gridfsKey(raw, accessor.config);
-  const rec = recordStream("read", virtual, ResourceName3.GRIDFS);
+  const rec = recordStream("read", virtual, ResourceName4.GRIDFS);
   const fileId = await resolveFileId(accessor, path, key);
   if (rec !== null) {
     const revision = fileId.toString();
@@ -698,15 +720,16 @@ async function* stream(accessor, path) {
     yield pending;
   }
 }
-async function rangeRead(accessor, path, offset, size) {
-  return read(accessor, path, void 0, { offset, size });
+async function rangeRead(accessor, path, start, end) {
+  return read(accessor, path, void 0, { offset: start, size: end - start });
 }
 
 // src/core/gridfs/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 raw = rawPathOf(path);
   const key = gridfsKey(raw, accessor.config);
+  const startMs = performance.now();
   const doc = await latestFile(accessor, key);
   let data = doc === null ? new Uint8Array(0) : await downloadBytes(accessor, path, doc._id);
   if (data.byteLength > length) {
@@ -717,6 +740,7 @@ async function truncate(accessor, path, length) {
     data = padded;
   }
   await uploadBytes(accessor, key, data);
+  record4("truncate", path.virtual, ResourceName5.GRIDFS, 0, startMs);
   await invalidateAfterWrite6(path);
 }
 
@@ -733,6 +757,7 @@ async function unlink(accessor, path) {
 var GRIDFS_IO = {
   readdir,
   readBytes: read,
+  readRange: rangeOf(read),
   readStream: stream,
   stat,
   isMounted: () => true,
@@ -749,80 +774,77 @@ var GRIDFS_IO = {
   create,
   truncate,
   find,
-  duTotal: du,
-  duAll
+  du: { size, entries }
 };
 
-// src/commands/builtin/gridfs/du.ts
-var resolveGlob = resolveGlobOf(GRIDFS_IO);
-async function duCommand(accessor, paths, _texts, opts) {
-  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths, opts.index ?? void 0) : [];
-  return duGeneric(
-    resolved,
-    opts,
-    (p) => du(accessor, p),
-    (p) => duAll(accessor, p)
-  );
-}
-var GRIDFS_DU = command({
-  name: "du",
-  resource: ResourceName4.GRIDFS,
-  spec: specOf("du"),
-  fn: duCommand,
-  provision: metadataProvision
-});
-
 // src/commands/builtin/gridfs/mkdir.ts
 import {
+  FlagView,
   IOResult,
-  ResourceName as ResourceName5,
-  command as command2,
-  resolveGlobOf as resolveGlobOf2,
-  specOf as specOf2,
-  writeMetadataProvision
+  ResourceName as ResourceName6,
+  command,
+  resolveGlobOf,
+  specOf
 } from "@struktoai/mirage-core";
-var resolveGlob2 = resolveGlobOf2(GRIDFS_IO);
+import { mkdirLinkRefusal } from "@struktoai/mirage-core";
+var resolveGlob = resolveGlobOf(GRIDFS_IO);
 var ENC = new TextEncoder();
 async function mkdirCommand(accessor, paths, _texts, opts) {
   if (paths.length === 0) {
     return [null, new IOResult({ exitCode: 1, stderr: ENC.encode("mkdir: missing operand\n") })];
   }
-  const resolved = await resolveGlob2(accessor, paths, opts.index ?? void 0);
-  const verbose = opts.flags.v === true;
-  const parents = opts.flags.p === true;
+  const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+  const fl = new FlagView(opts.flags, specOf("mkdir"));
+  const verbose = fl.asBool("verbose");
+  const parents = fl.asBool("parents");
   const lines = [];
   const writes = {};
+  const errors = [];
+  const links = opts.ns?.links ?? null;
   for (const path of resolved) {
+    const collision = await mkdirLinkRefusal(path, links, { parents });
+    if (collision.taken) {
+      if (collision.message !== null) errors.push(collision.message);
+      continue;
+    }
     await mkdir(accessor, path, parents);
     writes[path.mountPath] = new Uint8Array();
     if (verbose) lines.push(`mkdir: created directory '${path.virtual}'`);
   }
   const output = lines.length > 0 ? ENC.encode(lines.join("\n") + "\n") : null;
-  return [output, new IOResult({ writes })];
+  const stderr = errors.length > 0 ? ENC.encode(errors.join("\n") + "\n") : void 0;
+  return [
+    output,
+    new IOResult({
+      writes,
+      exitCode: errors.length > 0 ? 1 : 0,
+      ...stderr !== void 0 ? { stderr } : {}
+    })
+  ];
 }
-var GRIDFS_MKDIR = command2({
+var GRIDFS_MKDIR = command({
   name: "mkdir",
-  resource: ResourceName5.GRIDFS,
-  spec: specOf2("mkdir"),
+  resource: ResourceName6.GRIDFS,
+  spec: specOf("mkdir"),
   fn: mkdirCommand,
-  write: true,
-  provision: writeMetadataProvision
+  write: true
 });
 
 // src/commands/builtin/gridfs/rm.ts
 import {
   FileType as FileType2,
+  FlagView as FlagView2,
   IOResult as IOResult2,
-  ResourceName as ResourceName6,
-  command as command3,
+  ResourceName as ResourceName7,
+  command as command2,
   cpWalk,
   formatRecords,
   removalLines,
-  resolveGlobOf as resolveGlobOf3,
-  specOf as specOf3,
-  writeMetadataProvision as writeMetadataProvision2
+  resolveGlobOf as resolveGlobOf2,
+  specOf as specOf2
 } from "@struktoai/mirage-core";
-var resolveGlob3 = resolveGlobOf3(GRIDFS_IO);
+import { isSlashedLink, rmLinkRefusal } from "@struktoai/mirage-core";
+var resolveGlob2 = resolveGlobOf2(GRIDFS_IO);
 var ENC2 = new TextEncoder();
 async function rmOne(accessor, path, opts, index) {
   const label = path.virtual;
@@ -864,15 +886,22 @@ async function rmCommand(accessor, paths, _texts, opts) {
   if (paths.length === 0) {
     return [null, new IOResult2({ exitCode: 1, stderr: ENC2.encode("rm: missing operand\n") })];
   }
-  const resolved = await resolveGlob3(accessor, paths, opts.index ?? void 0);
-  const recursive = opts.flags.r === true || opts.flags.R === true;
-  const force = opts.flags.f === true;
-  const removeDir = opts.flags.d === true;
-  const verbose = opts.flags.v === true;
+  const resolved = await resolveGlob2(accessor, paths, opts.index ?? void 0);
+  const fl = new FlagView2(opts.flags, specOf2("rm"));
+  const recursive = fl.asBool("r") || fl.asBool("R");
+  const force = fl.asBool("f");
+  const removeDir = fl.asBool("d");
+  const verbose = fl.asBool("v");
   const verboseParts = [];
   const errors = [];
   const writes = {};
+  const links = opts.ns?.links ?? null;
   for (const p of resolved) {
+    if (isSlashedLink(p, links)) {
+      const refusal = await rmLinkRefusal(p, links, { recursive, force });
+      if (refusal !== null) errors.push(refusal);
+      continue;
+    }
     const [error, entryLines] = await rmOne(
       accessor,
       p,
@@ -897,106 +926,89 @@ async function rmCommand(accessor, paths, _texts, opts) {
     })
   ];
 }
-var GRIDFS_RM = command3({
+var GRIDFS_RM = command2({
   name: "rm",
-  resource: ResourceName6.GRIDFS,
-  spec: specOf3("rm"),
+  resource: ResourceName7.GRIDFS,
+  spec: specOf2("rm"),
   fn: rmCommand,
-  write: true,
-  provision: writeMetadataProvision2
+  write: true
 });
 
 // src/commands/builtin/gridfs/stat.ts
 import {
-  ResourceName as ResourceName7,
-  command as command4,
-  metadataProvision as metadataProvision2,
-  resolveGlobOf as resolveGlobOf4,
-  specOf as specOf4,
+  ResourceName as ResourceName8,
+  command as command3,
+  overlaidStat,
+  resolveGlobOf as resolveGlobOf3,
+  specOf as specOf3,
   statGeneric
 } from "@struktoai/mirage-core";
-var resolveGlob4 = resolveGlobOf4(GRIDFS_IO);
+var resolveGlob3 = resolveGlobOf3(GRIDFS_IO);
 async function statCommand(accessor, paths, _texts, opts) {
-  const resolved = paths.length > 0 ? await resolveGlob4(accessor, paths, opts.index ?? void 0) : [];
-  return statGeneric(resolved, opts, (p) => stat(accessor, p, opts.index ?? void 0));
+  const resolved = paths.length > 0 ? await resolveGlob3(accessor, paths, opts.index ?? void 0) : [];
+  return statGeneric(
+    resolved,
+    opts,
+    overlaidStat((p) => stat(accessor, p, opts.index ?? void 0), opts.ns?.statOverlay)
+  );
 }
-var GRIDFS_STAT = command4({
+var GRIDFS_STAT = command3({
   name: "stat",
-  resource: ResourceName7.GRIDFS,
-  spec: specOf4("stat"),
-  fn: statCommand,
-  provision: metadataProvision2
+  resource: ResourceName8.GRIDFS,
+  spec: specOf3("stat"),
+  fn: statCommand
 });
 
 // src/commands/builtin/gridfs/tee.ts
 import {
   IOResult as IOResult3,
-  ResourceName as ResourceName8,
-  command as command5,
-  materialize,
-  parseTeeFlags,
-  readStdinAsync,
-  resolveGlobOf as resolveGlobOf5,
-  specOf as specOf5,
-  writeOutput
+  ResourceName as ResourceName9,
+  command as command4,
+  resolveGlobOf as resolveGlobOf4,
+  specOf as specOf4,
+  teeGeneric
 } from "@struktoai/mirage-core";
-var resolveGlob5 = resolveGlobOf5(GRIDFS_IO);
+var resolveGlob4 = resolveGlobOf4(GRIDFS_IO);
 var ENC3 = new TextEncoder();
 async function teeCommand(accessor, paths, texts, opts) {
   if (paths.length === 0) {
     return [null, new IOResult3({ exitCode: 1, stderr: ENC3.encode("tee: missing operand\n") })];
   }
-  const parsed = parseTeeFlags(opts.flags);
-  if (typeof parsed === "string") {
-    return [null, new IOResult3({ exitCode: 1, stderr: ENC3.encode(parsed) })];
-  }
-  const resolved = await resolveGlob5(accessor, paths, opts.index ?? void 0);
-  const first = resolved[0];
-  if (first === void 0) return [null, new IOResult3()];
-  const stdinData = await readStdinAsync(opts.stdin);
-  const raw = stdinData ?? ENC3.encode(texts.join(" "));
-  let writeData = raw;
-  if (parsed.append) {
-    let existingFound = false;
-    try {
-      existingFound = await exists(accessor, first);
-    } catch {
-      existingFound = false;
-    }
-    if (existingFound) {
-      const existing = await materialize(stream(accessor, first));
-      writeData = new Uint8Array(existing.byteLength + raw.byteLength);
-      writeData.set(existing, 0);
-      writeData.set(raw, existing.byteLength);
-    }
-  }
-  return writeOutput((p, d) => write(accessor, p, d), first, writeData, raw);
+  const resolved = await resolveGlob4(accessor, paths, opts.index ?? void 0);
+  return teeGeneric(
+    resolved,
+    texts,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => write(accessor, p, d)
+  );
 }
-var GRIDFS_TEE = command5({
+var GRIDFS_TEE = command4({
   name: "tee",
-  resource: ResourceName8.GRIDFS,
-  spec: specOf5("tee"),
+  resource: ResourceName9.GRIDFS,
+  spec: specOf4("tee"),
   fn: teeCommand,
   write: true
 });
 
 // src/commands/builtin/gridfs/touch.ts
 import {
+  FlagView as FlagView3,
   IOResult as IOResult4,
-  ResourceName as ResourceName9,
-  command as command6,
-  resolveGlobOf as resolveGlobOf6,
-  specOf as specOf6,
-  writeMetadataProvision as writeMetadataProvision3
+  ResourceName as ResourceName10,
+  command as command5,
+  resolveGlobOf as resolveGlobOf5,
+  specOf as specOf5
 } from "@struktoai/mirage-core";
-var resolveGlob6 = resolveGlobOf6(GRIDFS_IO);
+var resolveGlob5 = resolveGlobOf5(GRIDFS_IO);
 var ENC4 = new TextEncoder();
 async function touchCommand(accessor, paths, _texts, opts) {
   if (paths.length === 0) {
     return [null, new IOResult4({ exitCode: 1, stderr: ENC4.encode("touch: missing operand\n") })];
   }
-  const resolved = await resolveGlob6(accessor, paths, opts.index ?? void 0);
-  const createOnly = opts.flags.c === true;
+  const resolved = await resolveGlob5(accessor, paths, opts.index ?? void 0);
+  const fl = new FlagView3(opts.flags, specOf5("touch"));
+  const createOnly = fl.asBool("c");
   const writes = {};
   for (const p of resolved) {
     if (createOnly) continue;
@@ -1007,54 +1019,51 @@ async function touchCommand(accessor, paths, _texts, opts) {
   }
   return [null, new IOResult4({ writes })];
 }
-var GRIDFS_TOUCH = command6({
+var GRIDFS_TOUCH = command5({
   name: "touch",
-  resource: ResourceName9.GRIDFS,
-  spec: specOf6("touch"),
+  resource: ResourceName10.GRIDFS,
+  spec: specOf5("touch"),
   fn: touchCommand,
-  write: true,
-  provision: writeMetadataProvision3
+  write: true
 });
 
 // src/commands/builtin/gridfs/index.ts
-var GRIDFS_OVERRIDES = /* @__PURE__ */ new Set(["stat", "du", "rm", "mkdir", "tee", "touch"]);
+var GRIDFS_OVERRIDES = /* @__PURE__ */ new Set(["stat", "rm", "mkdir", "tee", "touch"]);
 var GRIDFS_COMMANDS = [
-  ...makeFiletypeCommands({
-    resource: ResourceName10.GRIDFS,
-    readBytes: read,
-    statEntry: stat
-  }),
-  ...makeGenericCommands(ResourceName10.GRIDFS, GRIDFS_IO, {
+  ...makeGenericCommands(ResourceName11.GRIDFS, GRIDFS_IO, {
     overrides: GRIDFS_OVERRIDES
   }),
-  ...GRIDFS_STAT,
-  ...GRIDFS_DU,
-  ...GRIDFS_RM,
-  ...GRIDFS_MKDIR,
-  ...GRIDFS_TEE,
-  ...GRIDFS_TOUCH
+  ...withDefaultProvisions(
+    [...GRIDFS_STAT, ...GRIDFS_RM, ...GRIDFS_MKDIR, ...GRIDFS_TEE, ...GRIDFS_TOUCH],
+    GRIDFS_IO.stat,
+    resolveGlobOf6(GRIDFS_IO),
+    GRIDFS_IO.readdir
+  )
 ];
 
 // src/ops/gridfs/index.ts
-import { ResourceName as ResourceName11, makeGenericOps } from "@struktoai/mirage-core";
-var GRIDFS_OPS = makeGenericOps(ResourceName11.GRIDFS, GRIDFS_IO, {
-  filetypeRead: [".feather", ".hdf5", ".parquet"]
-});
+import { ResourceName as ResourceName12, makeGenericOps } from "@struktoai/mirage-core";
+var GRIDFS_OPS = makeGenericOps(
+  ResourceName12.GRIDFS,
+  GRIDFS_IO,
+  {}
+);
 
 // src/resource/gridfs/prompt.ts
 var GRIDFS_PROMPT = `{prefix}
   Remote MongoDB GridFS bucket. Maps GridFS filenames to virtual paths.
   IMPORTANT: This is a remote mount. Prefer targeted reads (grep, head) over full scans. Avoid cat on large files without piping to head/tail.
   find pushes -name/-type/-size filters into the fs.files query server-side, so find is cheap even on large buckets.
-  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, jq, stat.
-  cat on .parquet/.orc/.feather returns a formatted table.`;
+  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, jq, stat.`;
 
 // src/resource/gridfs/gridfs.ts
 var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
 var GridFSResource = class extends BaseResource {
-  kind = ResourceName12.GRIDFS;
+  kind = ResourceName13.GRIDFS;
   cachesReads = true;
   supportsSnapshot = true;
+  // byte store: stat() sizes every file from metadata
+  sizesAlwaysKnown = true;
   indexTtl = 600;
   prompt = GRIDFS_PROMPT;
   config;
@@ -1072,8 +1081,8 @@ var GridFSResource = class extends BaseResource {
     read_stream: stream,
     range_read: rangeRead,
     rm_recursive: rmR,
-    du_total: du,
-    du_all: duAll,
+    du_size: size,
+    du_entries: entries,
     create,
     truncate,
     exists,
@@ -1096,6 +1105,7 @@ var GridFSResource = class extends BaseResource {
   }
   async close() {
     await this.accessor.close();
+    await super.close();
   }
   commands() {
     return GRIDFS_COMMANDS;
@@ -1159,7 +1169,7 @@ var GridFSResource = 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);
@@ -1189,6 +1199,7 @@ var GridFSResource = class extends BaseResource {
 
 export {
   GridFSAccessor,
+  GRIDFS_COMMANDS,
   GridFSResource
 };
-//# sourceMappingURL=chunk-CGGO5NKD.js.map
+//# sourceMappingURL=chunk-YUJBXFYK.js.map