@struktoai/mirage-node 0.0.3 → 0.0.4

package/dist/chunk-CGGO5NKD.js

@@ -0,0 +1,1194 @@
+import {
+  loadOptionalPeer
+} from "./chunk-OQKNDS66.js";
+import {
+  redactConfig
+} from "./chunk-C7TNKIK5.js";
+
+// src/resource/gridfs/gridfs.ts
+import {
+  BaseResource,
+  PathSpec,
+  ResourceName as ResourceName12,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf4,
+  normalizeKeyPrefix
+} from "@struktoai/mirage-core";
+
+// src/accessor/gridfs.ts
+import { Accessor } from "@struktoai/mirage-core";
+var GridFSAccessor = class extends Accessor {
+  config;
+  clientPromise = null;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async client() {
+    this.clientPromise ??= this._connect();
+    return this.clientPromise;
+  }
+  async db() {
+    const client = await this.client();
+    return client.db(this.config.database);
+  }
+  async _connect() {
+    const mod = await loadOptionalPeer(() => import("mongodb"), {
+      feature: "GridFSResource",
+      packageName: "mongodb"
+    });
+    const client = new mod.MongoClient(this.config.uri);
+    await client.connect();
+    return client;
+  }
+  async close() {
+    if (this.clientPromise === null) return;
+    const client = await this.clientPromise;
+    this.clientPromise = null;
+    await client.close();
+  }
+};
+
+// src/commands/builtin/gridfs/index.ts
+import {
+  ResourceName as ResourceName10,
+  makeFiletypeCommands,
+  makeGenericCommands
+} from "@struktoai/mirage-core";
+
+// src/core/gridfs/read.ts
+import {
+  ResourceName,
+  enoent,
+  record,
+  revisionFor
+} from "@struktoai/mirage-core";
+
+// src/core/gridfs/_client.ts
+import { keyPrefix as kp, mountPrefixOf } from "@struktoai/mirage-core";
+var LATEST_SORT = { uploadDate: -1, _id: -1 };
+var BATCH = 1e3;
+var cachedModule = null;
+async function loadGridFSModule() {
+  cachedModule ??= loadOptionalPeer(() => import("mongodb"), {
+    feature: "GridFSResource",
+    packageName: "mongodb"
+  });
+  return cachedModule;
+}
+function gridfsKey(path, config) {
+  return kp.apply(config.keyPrefix ?? "", path);
+}
+function gridfsPrefix(path, config) {
+  return kp.applyDir(config.keyPrefix ?? "", path);
+}
+function stripKeyPrefix(key, config) {
+  return kp.strip(config.keyPrefix ?? "", key);
+}
+function rawPathOf(path) {
+  const prefix = mountPrefixOf(path.virtual, path.resourcePath);
+  return prefix !== "" && path.virtual.startsWith(prefix) ? path.virtual.slice(prefix.length) || "/" : path.virtual;
+}
+function bucketName(config) {
+  return config.bucket ?? "fs";
+}
+async function filesColl(accessor) {
+  const db = await accessor.db();
+  return db.collection(`${bucketName(accessor.config)}.files`);
+}
+async function chunksColl(accessor) {
+  const db = await accessor.db();
+  return db.collection(`${bucketName(accessor.config)}.chunks`);
+}
+async function bucket(accessor) {
+  const mod = await loadGridFSModule();
+  const db = await accessor.db();
+  const options = {
+    bucketName: bucketName(accessor.config)
+  };
+  if (accessor.config.chunkSizeBytes !== void 0) {
+    options.chunkSizeBytes = accessor.config.chunkSizeBytes;
+  }
+  return new mod.GridFSBucket(db, options);
+}
+function escapeRegex(raw) {
+  let out = "";
+  for (const ch of raw) {
+    out += "\\^$.|?*+()[]{}".includes(ch) ? `\\${ch}` : ch;
+  }
+  return out;
+}
+function prefixQuery(pfx) {
+  if (pfx === "") return {};
+  return { filename: { $regex: `^${escapeRegex(pfx)}` } };
+}
+async function latestFile(accessor, key) {
+  const files = await filesColl(accessor);
+  const doc = await files.findOne({ filename: key }, { sort: LATEST_SORT });
+  return doc;
+}
+async function* iterLatest(accessor, query) {
+  const files = await filesColl(accessor);
+  const pipeline = [
+    { $match: query },
+    { $sort: { filename: 1, uploadDate: -1, _id: -1 } },
+    {
+      $group: {
+        _id: "$filename",
+        fid: { $first: "$_id" },
+        length: { $first: "$length" },
+        uploadDate: { $first: "$uploadDate" }
+      }
+    },
+    { $sort: { _id: 1 } }
+  ];
+  for await (const doc of files.aggregate(pipeline)) {
+    yield {
+      filename: doc._id,
+      _id: doc.fid,
+      length: doc.length,
+      uploadDate: doc.uploadDate
+    };
+  }
+}
+async function deleteAll(accessor, query) {
+  const files = await filesColl(accessor);
+  const chunks = await chunksColl(accessor);
+  const ids = [];
+  for await (const doc of files.find(query, { projection: { _id: 1 } })) {
+    ids.push(doc._id);
+  }
+  for (let i = 0; i < ids.length; i += BATCH) {
+    const batch = ids.slice(i, i + BATCH);
+    await chunks.deleteMany({ files_id: { $in: batch } });
+    await files.deleteMany({ _id: { $in: batch } });
+  }
+}
+
+// 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 = {}) {
+  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;
+}
+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();
+  record("read", virtual, ResourceName.GRIDFS, bytes.byteLength, startMs, {
+    fingerprint: revision,
+    revision
+  });
+  return bytes;
+}
+
+// src/core/gridfs/stat.ts
+import {
+  FileStat,
+  FileType,
+  enoent as enoent2,
+  gnuBasename,
+  guessType,
+  mountPrefixOf as mountPrefixOf2,
+  rstripSlash,
+  stripSlash
+} from "@struktoai/mirage-core";
+async function stat(accessor, path, index) {
+  const original = path.virtual;
+  const prefix = mountPrefixOf2(path.virtual, path.resourcePath);
+  const rawPath = prefix !== "" && original.startsWith(prefix) ? original.slice(prefix.length) || "/" : original;
+  const stripped = stripSlash(rawPath);
+  if (stripped === "") {
+    return new FileStat({ name: "/", type: FileType.DIRECTORY });
+  }
+  const hintsDirectory = rawPath.endsWith("/");
+  if (index !== void 0) {
+    const virtualKey = prefix !== "" ? `${prefix}/${stripped}` : "/" + stripped;
+    const lookup = await index.get(virtualKey);
+    if (lookup.entry !== void 0 && lookup.entry !== null) {
+      const entry = lookup.entry;
+      if (entry.resourceType === "folder") {
+        return new FileStat({ name: entry.name, type: FileType.DIRECTORY });
+      }
+      return new FileStat({
+        name: entry.name,
+        size: entry.size ?? null,
+        modified: entry.remoteTime !== "" ? entry.remoteTime : null,
+        type: guessType(entry.name)
+      });
+    }
+    const parent = virtualKey.replace(/\/[^/]*$/, "") || "/";
+    const parentListing = await index.listDir(parent);
+    if (parentListing.entries !== void 0 && parentListing.entries !== null) {
+      throw enoent2(path);
+    }
+  }
+  const { config } = accessor;
+  const key = gridfsKey(rawPath, config);
+  if (!hintsDirectory) {
+    const doc = await latestFile(accessor, key);
+    if (doc !== null) {
+      const revision = doc._id.toString();
+      return new FileStat({
+        name: gnuBasename(rawPath),
+        size: doc.length,
+        modified: doc.uploadDate.toISOString(),
+        fingerprint: revision,
+        revision,
+        type: guessType(rawPath),
+        extra: { file_id: revision }
+      });
+    }
+  }
+  const pfx = rstripSlash(key) + "/";
+  const files = await filesColl(accessor);
+  const probe = await files.findOne(
+    { filename: { $regex: `^${escapeRegex(pfx)}` } },
+    { projection: { _id: 1 } }
+  );
+  if (probe !== null) {
+    return new FileStat({ name: gnuBasename(rawPath) || "/", type: FileType.DIRECTORY });
+  }
+  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 {
+    await stat(accessor, path);
+    return true;
+  } catch (err) {
+    if (err?.code === "ENOENT") return false;
+    throw err;
+  }
+}
+
+// src/core/gridfs/find.ts
+import {
+  buildTree,
+  emitStartPath,
+  keep,
+  rstripSlash as rstripSlash3,
+  startBasename
+} from "@struktoai/mirage-core";
+function globRegex(pattern) {
+  if (pattern.includes("[") || pattern.includes("]")) return null;
+  let out = "";
+  for (const ch of pattern) {
+    if (ch === "*") out += "[^/]*";
+    else if (ch === "?") out += "[^/]";
+    else out += escapeRegex(ch);
+  }
+  return out;
+}
+function buildQuery(pfx, options, pushdown) {
+  const conds = [];
+  const base = prefixQuery(pfx);
+  if (Object.keys(base).length > 0) conds.push(base);
+  if (pushdown) {
+    const escaped = escapeRegex(pfx);
+    const globs = [
+      [options.name, ""],
+      [options.iname, "i"]
+    ];
+    for (const [pat, flags] of globs) {
+      if (pat === void 0 || pat === null) continue;
+      const rx = globRegex(pat);
+      if (rx === null) continue;
+      const regex = { $regex: `^${escaped}(.*/)?${rx}/?$` };
+      if (flags !== "") regex.$options = flags;
+      conds.push({ filename: regex });
+    }
+    if (options.type === "f") {
+      conds.push({ filename: { $not: { $regex: "/$" } } });
+    } else if (options.type === "d") {
+      conds.push({ filename: { $regex: "/$" } });
+    }
+    if (options.minSize != null || options.maxSize != null) {
+      const sizeCond = {};
+      if (options.minSize != null) sizeCond.$gte = options.minSize;
+      if (options.maxSize != null) sizeCond.$lte = options.maxSize;
+      conds.push({ $or: [{ length: sizeCond }, { filename: { $regex: "/$" } }] });
+    }
+  }
+  if (conds.length === 0) return {};
+  if (conds.length === 1) return conds[0] ?? {};
+  return { $and: conds };
+}
+async function find(accessor, path, options = {}) {
+  const raw = rawPathOf(path);
+  const startName = startBasename(path.virtual);
+  const pfx = gridfsPrefix(raw, accessor.config);
+  const results = [];
+  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 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 query = buildQuery(pfx, options, pushdown);
+  const narrowed = JSON.stringify(query) !== JSON.stringify(prefixQuery(pfx));
+  for await (const doc of iterLatest(accessor, query)) {
+    const key = doc.filename;
+    if (key === pfx) {
+      seen.marker = true;
+      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;
+    }
+    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;
+    }
+    results.push(fullPath);
+  }
+  if (narrowed && !seen.descendant && !seen.marker) {
+    const files = await filesColl(accessor);
+    const probe = await files.findOne(
+      pfx === "" ? {} : { filename: { $regex: `^${escapeRegex(pfx)}` } },
+      { projection: { _id: 1 } }
+    );
+    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,
+      exists: true,
+      tree,
+      maxDepth: options.maxDepth,
+      minDepth: options.minDepth,
+      minSize: options.minSize,
+      maxSize: options.maxSize
+    });
+  }
+  return results.sort();
+}
+
+// src/core/gridfs/mkdir.ts
+import { invalidateAfterWrite as invalidateAfterWrite4, invalidateAncestors } 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);
+}
+
+// src/core/gridfs/readdir.ts
+import {
+  IndexEntry,
+  ResourceType,
+  mountPrefixOf as mountPrefixOf3,
+  rstripSlash as rstripSlash4
+} 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 rawFullKey = prefix !== "" ? `${prefix}${virtualKey}` : virtualKey;
+  const fullVirtualKey = rstripSlash4(rawFullKey) || "/";
+  if (index !== void 0) {
+    const listing = await index.listDir(fullVirtualKey);
+    if (listing.entries !== void 0 && listing.entries !== null) {
+      return listing.entries;
+    }
+  }
+  const { config } = accessor;
+  const pfx = gridfsPrefix(rawPath, config);
+  const names = [];
+  const dirKeys = /* @__PURE__ */ new Set();
+  const sizes = /* @__PURE__ */ new Map();
+  const times = /* @__PURE__ */ new Map();
+  for await (const doc of iterLatest(accessor, prefixQuery(pfx))) {
+    const fname = doc.filename;
+    if (fname === pfx) continue;
+    const relative = fname.slice(pfx.length);
+    const slash = relative.indexOf("/");
+    if (slash === -1) {
+      const key = "/" + stripKeyPrefix(fname, config);
+      names.push(key);
+      sizes.set(key, doc.length);
+      times.set(key, doc.uploadDate.toISOString());
+    } else {
+      const child = pfx + relative.slice(0, slash);
+      const key = "/" + stripKeyPrefix(child, config);
+      if (!dirKeys.has(key)) {
+        names.push(key);
+        dirKeys.add(key);
+      }
+    }
+  }
+  names.sort();
+  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();
+  if (index !== void 0) {
+    const indexEntries = names.map((e) => {
+      const name = e.split("/").pop() ?? "";
+      if (dirKeys.has(e)) {
+        return [name, new IndexEntry({ id: e, name, resourceType: ResourceType.FOLDER })];
+      }
+      return [
+        name,
+        new IndexEntry({
+          id: e,
+          name,
+          resourceType: ResourceType.FILE,
+          size: sizes.get(e) ?? null,
+          remoteTime: times.get(e) ?? ""
+        })
+      ];
+    });
+    await index.setDir(fullVirtualKey, indexEntries);
+  }
+  return virtualEntries;
+}
+
+// src/core/gridfs/rename.ts
+import {
+  enoent as enoent4,
+  invalidateAfterUnlink,
+  invalidateAfterWrite as invalidateAfterWrite5
+} from "@struktoai/mirage-core";
+async function rename(accessor, src, dst) {
+  const srcKey = gridfsKey(rawPathOf(src), accessor.config);
+  const dstKey = gridfsKey(rawPathOf(dst), accessor.config);
+  if (await latestFile(accessor, srcKey) === null) {
+    throw enoent4(src);
+  }
+  await deleteAll(accessor, { filename: dstKey });
+  const files = await filesColl(accessor);
+  await files.updateMany({ filename: srcKey }, { $set: { filename: dstKey } });
+  await invalidateAfterWrite5(dst);
+  await invalidateAfterUnlink(src);
+}
+
+// src/core/gridfs/rm.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink2 } from "@struktoai/mirage-core";
+async function rmR(accessor, path) {
+  const raw = rawPathOf(path);
+  const pfx = gridfsPrefix(raw, accessor.config);
+  await deleteAll(accessor, prefixQuery(pfx));
+  await invalidateAfterUnlink2(path);
+}
+
+// src/core/gridfs/rmdir.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink3 } from "@struktoai/mirage-core";
+async function rmdir(accessor, path) {
+  const raw = rawPathOf(path);
+  const pfx = gridfsPrefix(raw, accessor.config);
+  await deleteAll(accessor, prefixQuery(pfx));
+  await invalidateAfterUnlink3(path);
+}
+
+// src/core/gridfs/stream.ts
+import { ResourceName as ResourceName3, 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 fileId = await resolveFileId(accessor, path, key);
+  if (rec !== null) {
+    const revision = fileId.toString();
+    rec.fingerprint = revision;
+    rec.revision = revision;
+  }
+  const b = await bucket(accessor);
+  const readable = b.openDownloadStream(fileId);
+  let pending = new Uint8Array(0);
+  try {
+    for await (const chunk of readable) {
+      const merged = new Uint8Array(pending.byteLength + chunk.byteLength);
+      merged.set(pending, 0);
+      merged.set(chunk, pending.byteLength);
+      pending = merged;
+      while (pending.byteLength >= DEFAULT_CHUNK_SIZE) {
+        const piece = pending.slice(0, DEFAULT_CHUNK_SIZE);
+        if (rec !== null) rec.bytes += piece.byteLength;
+        yield piece;
+        pending = pending.slice(DEFAULT_CHUNK_SIZE);
+      }
+    }
+  } catch (err) {
+    if (isNoFileError(err)) throw enoent5(path);
+    throw err;
+  }
+  if (pending.byteLength > 0) {
+    if (rec !== null) rec.bytes += pending.byteLength;
+    yield pending;
+  }
+}
+async function rangeRead(accessor, path, offset, size) {
+  return read(accessor, path, void 0, { offset, size });
+}
+
+// src/core/gridfs/truncate.ts
+import { invalidateAfterWrite as invalidateAfterWrite6 } from "@struktoai/mirage-core";
+async function truncate(accessor, path, length) {
+  const raw = rawPathOf(path);
+  const key = gridfsKey(raw, accessor.config);
+  const doc = await latestFile(accessor, key);
+  let data = doc === null ? new Uint8Array(0) : await downloadBytes(accessor, path, doc._id);
+  if (data.byteLength > length) {
+    data = data.slice(0, length);
+  } else if (data.byteLength < length) {
+    const padded = new Uint8Array(length);
+    padded.set(data, 0);
+    data = padded;
+  }
+  await uploadBytes(accessor, key, data);
+  await invalidateAfterWrite6(path);
+}
+
+// src/core/gridfs/unlink.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink4 } from "@struktoai/mirage-core";
+async function unlink(accessor, path) {
+  const raw = rawPathOf(path);
+  const key = gridfsKey(raw, accessor.config);
+  await deleteAll(accessor, { filename: key });
+  await invalidateAfterUnlink4(path);
+}
+
+// src/commands/builtin/gridfs/io.ts
+var GRIDFS_IO = {
+  readdir,
+  readBytes: read,
+  readStream: stream,
+  stat,
+  isMounted: () => true,
+  local: false,
+  maxGlobMatches: SCOPE_ERROR,
+  write,
+  exists,
+  mkdir,
+  unlink,
+  rmdir,
+  rmR,
+  rename,
+  copy,
+  create,
+  truncate,
+  find,
+  duTotal: du,
+  duAll
+};
+
+// 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 {
+  IOResult,
+  ResourceName as ResourceName5,
+  command as command2,
+  resolveGlobOf as resolveGlobOf2,
+  specOf as specOf2,
+  writeMetadataProvision
+} from "@struktoai/mirage-core";
+var resolveGlob2 = resolveGlobOf2(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 lines = [];
+  const writes = {};
+  for (const path of resolved) {
+    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 })];
+}
+var GRIDFS_MKDIR = command2({
+  name: "mkdir",
+  resource: ResourceName5.GRIDFS,
+  spec: specOf2("mkdir"),
+  fn: mkdirCommand,
+  write: true,
+  provision: writeMetadataProvision
+});
+
+// src/commands/builtin/gridfs/rm.ts
+import {
+  FileType as FileType2,
+  IOResult as IOResult2,
+  ResourceName as ResourceName6,
+  command as command3,
+  cpWalk,
+  formatRecords,
+  removalLines,
+  resolveGlobOf as resolveGlobOf3,
+  specOf as specOf3,
+  writeMetadataProvision as writeMetadataProvision2
+} from "@struktoai/mirage-core";
+var resolveGlob3 = resolveGlobOf3(GRIDFS_IO);
+var ENC2 = new TextEncoder();
+async function rmOne(accessor, path, opts, index) {
+  const label = path.virtual;
+  let isDir = false;
+  try {
+    const st = await stat(accessor, path, index ?? void 0);
+    isDir = st.type === FileType2.DIRECTORY;
+  } catch {
+    if (opts.force) return [null, []];
+    return [`rm: cannot remove '${label}': No such file or directory`, []];
+  }
+  if (isDir) {
+    if (opts.recursive) {
+      const lines = opts.verbose ? removalLines(
+        await cpWalk(
+          (dir) => readdir(accessor, dir, index ?? void 0),
+          (spec) => stat(accessor, spec, index ?? void 0),
+          path,
+          index ?? void 0
+        )
+      ) : [];
+      await rmR(accessor, path);
+      return [null, lines];
+    }
+    if (opts.removeDir) {
+      const children = await readdir(accessor, path, index ?? void 0);
+      if (children.length > 0) {
+        return [`rm: cannot remove '${label}': Directory not empty`, []];
+      }
+      await rmdir(accessor, path);
+      return [null, opts.verbose ? [`removed directory '${label}'`] : []];
+    }
+    return [`rm: cannot remove '${label}': Is a directory`, []];
+  }
+  await unlink(accessor, path);
+  return [null, opts.verbose ? [`removed '${label}'`] : []];
+}
+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 verboseParts = [];
+  const errors = [];
+  const writes = {};
+  for (const p of resolved) {
+    const [error, entryLines] = await rmOne(
+      accessor,
+      p,
+      { recursive, force, removeDir, verbose },
+      opts.index
+    );
+    if (error !== null) {
+      errors.push(error);
+      continue;
+    }
+    writes[p.mountPath] = new Uint8Array();
+    if (verbose) verboseParts.push(...entryLines);
+  }
+  const output = verbose ? formatRecords(verboseParts) : null;
+  const stderr = errors.length > 0 ? ENC2.encode(errors.join("\n") + "\n") : void 0;
+  return [
+    output,
+    new IOResult2({
+      writes,
+      exitCode: errors.length > 0 ? 1 : 0,
+      ...stderr !== void 0 ? { stderr } : {}
+    })
+  ];
+}
+var GRIDFS_RM = command3({
+  name: "rm",
+  resource: ResourceName6.GRIDFS,
+  spec: specOf3("rm"),
+  fn: rmCommand,
+  write: true,
+  provision: writeMetadataProvision2
+});
+
+// src/commands/builtin/gridfs/stat.ts
+import {
+  ResourceName as ResourceName7,
+  command as command4,
+  metadataProvision as metadataProvision2,
+  resolveGlobOf as resolveGlobOf4,
+  specOf as specOf4,
+  statGeneric
+} from "@struktoai/mirage-core";
+var resolveGlob4 = resolveGlobOf4(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));
+}
+var GRIDFS_STAT = command4({
+  name: "stat",
+  resource: ResourceName7.GRIDFS,
+  spec: specOf4("stat"),
+  fn: statCommand,
+  provision: metadataProvision2
+});
+
+// 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
+} from "@struktoai/mirage-core";
+var resolveGlob5 = resolveGlobOf5(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);
+}
+var GRIDFS_TEE = command5({
+  name: "tee",
+  resource: ResourceName8.GRIDFS,
+  spec: specOf5("tee"),
+  fn: teeCommand,
+  write: true
+});
+
+// src/commands/builtin/gridfs/touch.ts
+import {
+  IOResult as IOResult4,
+  ResourceName as ResourceName9,
+  command as command6,
+  resolveGlobOf as resolveGlobOf6,
+  specOf as specOf6,
+  writeMetadataProvision as writeMetadataProvision3
+} from "@struktoai/mirage-core";
+var resolveGlob6 = resolveGlobOf6(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 writes = {};
+  for (const p of resolved) {
+    if (createOnly) continue;
+    if (!await exists(accessor, p)) {
+      await write(accessor, p, new Uint8Array(0));
+      writes[p.mountPath] = new Uint8Array();
+    }
+  }
+  return [null, new IOResult4({ writes })];
+}
+var GRIDFS_TOUCH = command6({
+  name: "touch",
+  resource: ResourceName9.GRIDFS,
+  spec: specOf6("touch"),
+  fn: touchCommand,
+  write: true,
+  provision: writeMetadataProvision3
+});
+
+// src/commands/builtin/gridfs/index.ts
+var GRIDFS_OVERRIDES = /* @__PURE__ */ new Set(["stat", "du", "rm", "mkdir", "tee", "touch"]);
+var GRIDFS_COMMANDS = [
+  ...makeFiletypeCommands({
+    resource: ResourceName10.GRIDFS,
+    readBytes: read,
+    statEntry: stat
+  }),
+  ...makeGenericCommands(ResourceName10.GRIDFS, GRIDFS_IO, {
+    overrides: GRIDFS_OVERRIDES
+  }),
+  ...GRIDFS_STAT,
+  ...GRIDFS_DU,
+  ...GRIDFS_RM,
+  ...GRIDFS_MKDIR,
+  ...GRIDFS_TEE,
+  ...GRIDFS_TOUCH
+];
+
+// 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"]
+});
+
+// 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.`;
+
+// src/resource/gridfs/gridfs.ts
+var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
+var GridFSResource = class extends BaseResource {
+  kind = ResourceName12.GRIDFS;
+  cachesReads = true;
+  supportsSnapshot = true;
+  indexTtl = 600;
+  prompt = GRIDFS_PROMPT;
+  config;
+  accessor;
+  opsMap = {
+    read_bytes: read,
+    write,
+    readdir,
+    stat,
+    unlink,
+    rmdir,
+    copy,
+    rename,
+    mkdir,
+    read_stream: stream,
+    range_read: rangeRead,
+    rm_recursive: rmR,
+    du_total: du,
+    du_all: duAll,
+    create,
+    truncate,
+    exists,
+    find_flat: find
+  };
+  constructor(config) {
+    super();
+    const normalized = normalizeKeyPrefix(config.keyPrefix);
+    const cfg = { ...config };
+    if (normalized !== void 0) {
+      cfg.keyPrefix = normalized;
+    } else {
+      delete cfg.keyPrefix;
+    }
+    this.config = cfg;
+    this.accessor = new GridFSAccessor(this.config);
+  }
+  open() {
+    return Promise.resolve();
+  }
+  async close() {
+    await this.accessor.close();
+  }
+  commands() {
+    return GRIDFS_COMMANDS;
+  }
+  ops() {
+    return GRIDFS_OPS;
+  }
+  streamPath(p) {
+    return stream(this.accessor, p);
+  }
+  readFile(p) {
+    return read(this.accessor, p);
+  }
+  writeFile(p, data) {
+    return write(this.accessor, p, data);
+  }
+  async appendFile(p, data) {
+    let existing;
+    try {
+      existing = await read(this.accessor, p);
+    } catch (err) {
+      if (err?.code === "ENOENT") {
+        existing = new Uint8Array();
+      } else {
+        throw err;
+      }
+    }
+    const merged = new Uint8Array(existing.byteLength + data.byteLength);
+    merged.set(existing, 0);
+    merged.set(data, existing.byteLength);
+    await write(this.accessor, p, merged);
+  }
+  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) {
+    return mkdir(this.accessor, p);
+  }
+  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) => mountPrefixOf4(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);
+  }
+  getState() {
+    return Promise.resolve({
+      type: this.kind,
+      config: redactConfig(this.config)
+    });
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  GridFSAccessor,
+  GridFSResource
+};
+//# sourceMappingURL=chunk-CGGO5NKD.js.map