@struktoai/mirage-node 0.0.3 → 0.0.4

package/dist/{chunk-XWVDS66D.js → chunk-W5ZLIQFR.js}

@@ -1,14 +1,13 @@
-import {
-  SCOPE_ERROR
-} from "./chunk-U6QSXTUS.js";
-
 // src/resource/disk/disk.ts
-import { mkdir as mkdir5, readdir as readdir4, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir5, readdir as readdir4, readFile as readFile3, stat as fsStat3, writeFile as writeFile3 } from "fs/promises";
 import path8 from "path";
 import {
   BaseResource,
-  PathSpec as PathSpec2,
-  ResourceName as ResourceName21
+  PathSpec,
+  ResourceName as ResourceName7,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf2
 } from "@struktoai/mirage-core";
 
 // src/commands/builtin/disk/index.ts
@@ -39,7 +38,7 @@ function resolveSafe(root, virtual) {
 // src/core/disk/read.ts
 async function read(accessor, path9) {
   const start = performance.now();
-  const virtual = path9.stripPrefix;
+  const virtual = path9.mountPath;
   const full = resolveSafe(accessor.root, virtual);
   let data;
   try {
@@ -59,7 +58,7 @@ import { stat as fsStat } from "fs/promises";
 import path2 from "path";
 import { enoent as enoent2, FileStat, FileType, guessType } from "@struktoai/mirage-core";
 async function stat(accessor, p) {
-  const virtual = p.stripPrefix;
+  const virtual = p.mountPath;
   const full = resolveSafe(accessor.root, virtual);
   let st;
   try {
@@ -77,7 +76,9 @@ async function stat(accessor, p) {
       name,
       size: null,
       modified,
-      type: FileType.DIRECTORY
+      type: FileType.DIRECTORY,
+      mode: st.mode & 4095,
+      atime: st.atime.toISOString()
     });
   }
   return new FileStat({
@@ -85,18 +86,37 @@ async function stat(accessor, p) {
     size: st.size,
     modified,
     fingerprint: modified,
-    type: guessType(name)
+    type: guessType(name),
+    mode: st.mode & 4095,
+    atime: st.atime.toISOString()
   });
 }
 
-// src/core/disk/copy.ts
-import { copyFile, mkdir } from "fs/promises";
+// src/core/disk/append.ts
+import { appendFile, mkdir } from "fs/promises";
 import path3 from "path";
-import { enoent as enoent3, invalidateAfterWrite } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName2, invalidateAfterWrite, record as record2 } from "@struktoai/mirage-core";
+async function appendBytes(accessor, p, data) {
+  const start = performance.now();
+  const virtual = p.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  await mkdir(path3.dirname(full), { recursive: true });
+  await appendFile(full, data);
+  record2("append", virtual, ResourceName2.DISK, data.byteLength, start);
+  await invalidateAfterWrite(p);
+}
+
+// src/core/disk/constants.ts
+var SCOPE_ERROR = 5e4;
+
+// src/core/disk/copy.ts
+import { copyFile, mkdir as mkdir2 } from "fs/promises";
+import path4 from "path";
+import { enoent as enoent3, invalidateAfterWrite as invalidateAfterWrite2 } from "@struktoai/mirage-core";
 async function copy(accessor, src, dst) {
-  const s = resolveSafe(accessor.root, src.stripPrefix);
-  const d = resolveSafe(accessor.root, dst.stripPrefix);
-  await mkdir(path3.dirname(d), { recursive: true });
+  const s = resolveSafe(accessor.root, src.mountPath);
+  const d = resolveSafe(accessor.root, dst.mountPath);
+  await mkdir2(path4.dirname(d), { recursive: true });
   try {
     await copyFile(s, d);
   } catch (err) {
@@ -105,12 +125,31 @@ async function copy(accessor, src, dst) {
     }
     throw err;
   }
-  await invalidateAfterWrite(dst);
+  await invalidateAfterWrite2(dst);
+}
+
+// src/core/disk/write.ts
+import { mkdir as mkdir3, writeFile } from "fs/promises";
+import path5 from "path";
+import { ResourceName as ResourceName3, invalidateAfterWrite as invalidateAfterWrite3, record as record3 } from "@struktoai/mirage-core";
+async function writeBytes(accessor, p, data) {
+  const start = performance.now();
+  const virtual = p.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  await mkdir3(path5.dirname(full), { recursive: true });
+  await writeFile(full, data);
+  record3("write", virtual, ResourceName3.DISK, data.byteLength, start);
+  await invalidateAfterWrite3(p);
+}
+
+// src/core/disk/create.ts
+function create(accessor, path9) {
+  return writeBytes(accessor, path9, new Uint8Array());
 }
 
 // src/core/disk/du.ts
 import { readdir, stat as stat2 } from "fs/promises";
-import path4 from "path";
+import path6 from "path";
 async function walkSizes(full) {
   let total = 0;
   let st;
@@ -123,7 +162,7 @@ async function walkSizes(full) {
   if (!st.isDirectory()) return 0;
   const entries = await readdir(full, { withFileTypes: true });
   for (const e of entries) {
-    const child = path4.join(full, e.name);
+    const child = path6.join(full, e.name);
     if (e.isDirectory()) total += await walkSizes(child);
     else if (e.isFile()) {
       try {
@@ -144,20 +183,20 @@ async function walkAll(accessor, full, entries) {
     return 0;
   }
   if (st.isFile()) {
-    const rel = "/" + path4.relative(accessor.root, full).split(path4.sep).join("/");
+    const rel = "/" + path6.relative(accessor.root, full).split(path6.sep).join("/");
     entries.push([rel, st.size]);
     return st.size;
   }
   if (!st.isDirectory()) return 0;
   const children = await readdir(full, { withFileTypes: true });
   for (const e of children) {
-    const child = path4.join(full, e.name);
+    const child = path6.join(full, e.name);
     if (e.isDirectory()) {
       total += await walkAll(accessor, child, entries);
     } else if (e.isFile()) {
       try {
         const cst = await stat2(child);
-        const rel = "/" + path4.relative(accessor.root, child).split(path4.sep).join("/");
+        const rel = "/" + path6.relative(accessor.root, child).split(path6.sep).join("/");
         entries.push([rel, cst.size]);
         total += cst.size;
       } catch {
@@ -167,12 +206,12 @@ async function walkAll(accessor, full, entries) {
   return total;
 }
 async function du(accessor, p) {
-  const virtual = p.stripPrefix;
+  const virtual = p.mountPath;
   const full = resolveSafe(accessor.root, virtual);
   return walkSizes(full);
 }
 async function duAll(accessor, p) {
-  const virtual = norm(p.stripPrefix);
+  const virtual = norm(p.mountPath);
   const full = resolveSafe(accessor.root, virtual);
   const entries = [];
   const total = await walkAll(accessor, full, entries);
@@ -183,7 +222,7 @@ async function duAll(accessor, p) {
 // src/core/disk/exists.ts
 import { access } from "fs/promises";
 async function exists(accessor, path9) {
-  const full = resolveSafe(accessor.root, path9.stripPrefix);
+  const full = resolveSafe(accessor.root, path9.mountPath);
   try {
     await access(full);
     return true;
@@ -194,7 +233,7 @@ async function exists(accessor, path9) {
 
 // src/core/disk/find.ts
 import { readdir as readdir2, stat as stat3 } from "fs/promises";
-import path5 from "path";
+import path7 from "path";
 import {
   buildTree,
   emitStartPath,
@@ -223,7 +262,7 @@ async function walk(ctx, full, current, depth) {
     let isEmpty = null;
     if (accept && opts.empty === true) {
       try {
-        isEmpty = kind === "f" ? (await stat3(path5.join(full, e.name))).size === 0 : (await readdir2(path5.join(full, e.name))).length === 0;
+        isEmpty = kind === "f" ? (await stat3(path7.join(full, e.name))).size === 0 : (await readdir2(path7.join(full, e.name))).length === 0;
       } catch {
         isEmpty = null;
       }
@@ -235,9 +274,13 @@ async function walk(ctx, full, current, depth) {
     )) {
       accept = false;
     }
+    if (accept && kind !== "f" && (opts.minSize != null || opts.maxSize != null)) {
+      if (opts.minSize != null && opts.minSize > 0) accept = false;
+      if (opts.maxSize != null && opts.maxSize < 0) accept = false;
+    }
     if (accept && kind === "f" && (opts.minSize !== null || opts.maxSize !== null || opts.mtimeMin !== null || opts.mtimeMax !== null)) {
       try {
-        const st = await stat3(path5.join(full, e.name));
+        const st = await stat3(path7.join(full, e.name));
         if (opts.minSize !== null && opts.minSize !== void 0 && st.size < opts.minSize)
           accept = false;
         if (opts.maxSize !== null && opts.maxSize !== void 0 && st.size > opts.maxSize)
@@ -255,13 +298,13 @@ async function walk(ctx, full, current, depth) {
     }
     if (accept) ctx.results.push(entryPath);
     if (kind === "d") {
-      await walk(ctx, path5.join(full, e.name), entryPath, depth + 1);
+      await walk(ctx, path7.join(full, e.name), entryPath, depth + 1);
     }
   }
 }
 async function find(accessor, p, options = {}) {
-  const virtual = norm(p.stripPrefix);
-  const startName = startBasename(p.original);
+  const virtual = norm(p.mountPath);
+  const startName = startBasename(p.virtual);
   const full = resolveSafe(accessor.root, virtual);
   const baseDepth = virtual === "/" ? 0 : (virtual.match(/\//g) ?? []).length;
   const results = [];
@@ -295,7 +338,9 @@ async function find(accessor, p, options = {}) {
       exists: isDir,
       tree,
       maxDepth: options.maxDepth,
-      minDepth: options.minDepth
+      minDepth: options.minDepth,
+      minSize: options.minSize,
+      maxSize: options.maxSize
     });
   }
   await walk({ accessor, base: virtual, baseDepth, options, tree, results }, full, virtual, 0);
@@ -305,38 +350,40 @@ async function find(accessor, p, options = {}) {
 
 // src/core/disk/mkdir.ts
 import { mkdir as fsMkdir } from "fs/promises";
-import { invalidateAfterWrite as invalidateAfterWrite2 } from "@struktoai/mirage-core";
-async function mkdir2(accessor, path9, parents = false) {
-  const full = resolveSafe(accessor.root, path9.stripPrefix);
+import { invalidateAfterWrite as invalidateAfterWrite4, invalidateAncestors } from "@struktoai/mirage-core";
+async function mkdir4(accessor, path9, parents = false) {
+  const full = resolveSafe(accessor.root, path9.mountPath);
   if (parents) {
     await fsMkdir(full, { recursive: true });
-    await invalidateAfterWrite2(path9);
+    await invalidateAfterWrite4(path9);
+    await invalidateAncestors(path9);
     return;
   }
-  await invalidateAfterWrite2(path9);
   try {
     await fsMkdir(full);
   } catch (err) {
     const code = err.code;
-    if (code === "EEXIST") return;
     if (code === "ENOENT") {
-      throw new Error(`parent directory does not exist: ${path9.stripPrefix}`);
+      throw new Error(`parent directory does not exist: ${path9.mountPath}`);
     }
-    throw err;
+    if (code !== "EEXIST") throw err;
   }
+  await invalidateAfterWrite4(path9);
 }
 
 // src/core/disk/readdir.ts
 import { readdir as fsReaddir } from "fs/promises";
 import {
-  enotdir,
   IndexEntry,
-  ResourceType
+  ResourceType,
+  enotdir,
+  mountPrefixOf,
+  rstripSlash
 } from "@struktoai/mirage-core";
 async function readdir3(accessor, path9, index) {
-  const virtual = path9.pattern !== null ? path9.directory : path9.stripPrefix;
-  const mountPrefix = path9.prefix;
-  const virtualKey = mountPrefix + virtual;
+  const virtual = path9.pattern !== null ? path9.directory : path9.mountPath;
+  const mountPrefix = mountPrefixOf(path9.virtual, path9.resourcePath);
+  const virtualKey = rstripSlash(mountPrefix + virtual) || "/";
   if (index !== void 0) {
     const cached = await index.listDir(virtualKey);
     if (cached.entries !== void 0 && cached.entries !== null) {
@@ -376,11 +423,11 @@ import { rename as fsRename } from "fs/promises";
 import {
   enoent as enoent4,
   invalidateAfterUnlink,
-  invalidateAfterWrite as invalidateAfterWrite3
+  invalidateAfterWrite as invalidateAfterWrite5
 } from "@struktoai/mirage-core";
 async function rename(accessor, src, dst) {
-  const s = resolveSafe(accessor.root, src.stripPrefix);
-  const d = resolveSafe(accessor.root, dst.stripPrefix);
+  const s = resolveSafe(accessor.root, src.mountPath);
+  const d = resolveSafe(accessor.root, dst.mountPath);
   try {
     await fsRename(s, d);
   } catch (err) {
@@ -390,14 +437,14 @@ async function rename(accessor, src, dst) {
     throw err;
   }
   await invalidateAfterUnlink(src);
-  await invalidateAfterWrite3(dst);
+  await invalidateAfterWrite5(dst);
 }
 
 // src/core/disk/rm.ts
 import { rm } from "fs/promises";
 import { invalidateAfterUnlink as invalidateAfterUnlink2 } from "@struktoai/mirage-core";
 async function rmR(accessor, path9) {
-  const full = resolveSafe(accessor.root, path9.stripPrefix);
+  const full = resolveSafe(accessor.root, path9.mountPath);
   await rm(full, { recursive: true, force: true });
   await invalidateAfterUnlink2(path9);
 }
@@ -406,7 +453,7 @@ async function rmR(accessor, path9) {
 import { rmdir as fsRmdir } from "fs/promises";
 import { invalidateAfterUnlink as invalidateAfterUnlink3 } from "@struktoai/mirage-core";
 async function rmdir(accessor, path9) {
-  const full = resolveSafe(accessor.root, path9.stripPrefix);
+  const full = resolveSafe(accessor.root, path9.mountPath);
   try {
     await fsRmdir(full);
   } catch (err) {
@@ -416,13 +463,41 @@ async function rmdir(accessor, path9) {
   await invalidateAfterUnlink3(path9);
 }
 
+// src/core/disk/set_attrs.ts
+import { chmod, stat as fsStat2, utimes } from "fs/promises";
+import { enoent as enoent5 } from "@struktoai/mirage-core";
+async function setAttrs(accessor, path9, fields) {
+  const full = resolveSafe(accessor.root, path9.mountPath);
+  let st;
+  try {
+    st = await fsStat2(full);
+  } catch (err) {
+    if (err.code === "ENOENT") throw enoent5(path9);
+    throw err;
+  }
+  const residual = {};
+  if (fields.mode !== void 0) {
+    const keep2 = st.isDirectory() ? 448 : 384;
+    await chmod(full, fields.mode | keep2);
+    if ((fields.mode | keep2) !== fields.mode) residual.mode = fields.mode;
+  }
+  if (fields.uid !== void 0) residual.uid = fields.uid;
+  if (fields.gid !== void 0) residual.gid = fields.gid;
+  if (fields.atime !== void 0 || fields.mtime !== void 0) {
+    const newAtime = fields.atime !== void 0 ? new Date(fields.atime) : st.atime;
+    const newMtime = fields.mtime !== void 0 ? new Date(fields.mtime) : st.mtime;
+    await utimes(full, newAtime, newMtime);
+  }
+  return residual;
+}
+
 // src/core/disk/stream.ts
 import { createReadStream } from "fs";
-import { enoent as enoent5, recordStream, ResourceName as ResourceName2 } from "@struktoai/mirage-core";
+import { enoent as enoent6, recordStream, ResourceName as ResourceName4 } from "@struktoai/mirage-core";
 async function* stream(accessor, path9) {
-  const virtual = path9.stripPrefix;
+  const virtual = path9.mountPath;
   const full = resolveSafe(accessor.root, virtual);
-  const rec = recordStream("read", virtual, ResourceName2.DISK);
+  const rec = recordStream("read", virtual, ResourceName4.DISK);
   const rs = createReadStream(full, { highWaterMark: 65536 });
   try {
     for await (const chunk of rs) {
@@ -433,17 +508,38 @@ async function* stream(accessor, path9) {
     }
   } catch (err) {
     if (err.code === "ENOENT") {
-      throw enoent5(path9);
+      throw enoent6(path9);
     }
     throw err;
   }
 }
 
+// src/core/disk/truncate.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { invalidateAfterWrite as invalidateAfterWrite6 } from "@struktoai/mirage-core";
+async function truncate(accessor, path9, length) {
+  const full = resolveSafe(accessor.root, path9.mountPath);
+  let data;
+  try {
+    data = await readFile2(full);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      data = Buffer.alloc(0);
+    } else {
+      throw err;
+    }
+  }
+  const out = new Uint8Array(length);
+  out.set(data.subarray(0, Math.min(data.byteLength, length)));
+  await writeFile2(full, out);
+  await invalidateAfterWrite6(path9);
+}
+
 // src/core/disk/unlink.ts
 import { unlink as fsUnlink } from "fs/promises";
 import { invalidateAfterUnlink as invalidateAfterUnlink4 } from "@struktoai/mirage-core";
 async function unlink(accessor, path9) {
-  const full = resolveSafe(accessor.root, path9.stripPrefix);
+  const full = resolveSafe(accessor.root, path9.mountPath);
   try {
     await fsUnlink(full);
   } catch (err) {
@@ -453,22 +549,8 @@ async function unlink(accessor, path9) {
   await invalidateAfterUnlink4(path9);
 }
 
-// src/core/disk/write.ts
-import { mkdir as mkdir3, writeFile } from "fs/promises";
-import path6 from "path";
-import { ResourceName as ResourceName3, invalidateAfterWrite as invalidateAfterWrite4, record as record2 } from "@struktoai/mirage-core";
-async function writeBytes(accessor, p, data) {
-  const start = performance.now();
-  const virtual = p.stripPrefix;
-  const full = resolveSafe(accessor.root, virtual);
-  await mkdir3(path6.dirname(full), { recursive: true });
-  await writeFile(full, data);
-  record2("write", virtual, ResourceName3.DISK, data.byteLength, start);
-  await invalidateAfterWrite4(p);
-}
-
-// src/commands/builtin/disk/ops.ts
-var DISK_CMD_OPS = {
+// src/commands/builtin/disk/io.ts
+var DISK_IO = {
   readdir: readdir3,
   readBytes: read,
   readStream: stream,
@@ -478,25 +560,21 @@ var DISK_CMD_OPS = {
   maxGlobMatches: SCOPE_ERROR,
   write: writeBytes,
   exists,
-  mkdir: mkdir2,
+  mkdir: mkdir4,
   unlink,
   rmdir,
   rmR,
   rename,
   copy,
+  create,
+  truncate,
+  append: appendBytes,
+  setAttrs,
   find,
   duTotal: du,
   duAll
 };
 
-// src/commands/builtin/disk/sed.ts
-import { ResourceName as ResourceName4, makeSed } from "@struktoai/mirage-core";
-var DISK_SED = makeSed({
-  resource: ResourceName4.DISK,
-  stream: (a, p) => stream(a, p),
-  write: (a, p, d) => writeBytes(a, p, d)
-});
-
 // src/commands/builtin/disk/index.ts
 var DISK_COMMANDS = [
   ...makeFiletypeCommands({
@@ -504,89 +582,9 @@ var DISK_COMMANDS = [
     readBytes: read,
     statEntry: stat
   }),
-  ...makeGenericCommands(ResourceName5.DISK, DISK_CMD_OPS),
-  ...DISK_SED
+  ...makeGenericCommands(ResourceName5.DISK, DISK_IO)
 ];
 
-// src/core/disk/append.ts
-import { appendFile, mkdir as mkdir4 } from "fs/promises";
-import path7 from "path";
-import { ResourceName as ResourceName6, invalidateAfterWrite as invalidateAfterWrite5, record as record3 } from "@struktoai/mirage-core";
-async function appendBytes(accessor, p, data) {
-  const start = performance.now();
-  const virtual = p.stripPrefix;
-  const full = resolveSafe(accessor.root, virtual);
-  await mkdir4(path7.dirname(full), { recursive: true });
-  await appendFile(full, data);
-  record3("append", virtual, ResourceName6.DISK, data.byteLength, start);
-  await invalidateAfterWrite5(p);
-}
-
-// src/core/disk/create.ts
-function create(accessor, path9) {
-  return writeBytes(accessor, path9, new Uint8Array());
-}
-
-// src/core/disk/glob.ts
-import { PathSpec } from "@struktoai/mirage-core";
-import { fnmatch } from "@struktoai/mirage-core";
-import { gnuBasename as gnuBasename2 } from "@struktoai/mirage-core";
-async function resolveGlob(accessor, paths, index) {
-  const result = [];
-  for (const p of paths) {
-    if (p.resolved) {
-      result.push(p);
-    } else if (p.pattern !== null) {
-      const dirSpec = new PathSpec({
-        original: p.directory,
-        directory: p.directory,
-        resolved: true,
-        prefix: p.prefix
-      });
-      const entries = await readdir3(accessor, dirSpec, index);
-      const matched = [];
-      for (const e of entries) {
-        if (fnmatch(gnuBasename2(e), p.pattern)) {
-          matched.push(
-            new PathSpec({
-              original: e,
-              directory: p.directory,
-              resolved: true,
-              prefix: p.prefix
-            })
-          );
-        }
-      }
-      if (matched.length > SCOPE_ERROR) matched.length = SCOPE_ERROR;
-      result.push(...matched);
-    } else {
-      result.push(p);
-    }
-  }
-  return result;
-}
-
-// src/core/disk/truncate.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { invalidateAfterWrite as invalidateAfterWrite6 } from "@struktoai/mirage-core";
-async function truncate(accessor, path9, length) {
-  const full = resolveSafe(accessor.root, path9.stripPrefix);
-  let data;
-  try {
-    data = await readFile2(full);
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      data = Buffer.alloc(0);
-    } else {
-      throw err;
-    }
-  }
-  const out = new Uint8Array(length);
-  out.set(data.subarray(0, Math.min(data.byteLength, length)));
-  await writeFile2(full, out);
-  await invalidateAfterWrite6(path9);
-}
-
 // src/accessor/disk.ts
 import { Accessor } from "@struktoai/mirage-core";
 var DiskAccessor = class extends Accessor {
@@ -597,208 +595,13 @@ var DiskAccessor = class extends Accessor {
   }
 };
 
-// src/ops/disk/append.ts
-import { ResourceName as ResourceName7 } from "@struktoai/mirage-core";
-var appendOp = {
-  name: "append",
-  resource: ResourceName7.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9, args) => {
-    const data = args[0];
-    if (!(data instanceof Uint8Array)) {
-      throw new TypeError("append op requires a Uint8Array as the first arg");
-    }
-    return appendBytes(accessor, path9, data);
-  }
-};
-
-// src/ops/disk/create.ts
-import { ResourceName as ResourceName8 } from "@struktoai/mirage-core";
-var createOp = {
-  name: "create",
-  resource: ResourceName8.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9) => {
-    return create(accessor, path9);
-  }
-};
-
-// src/ops/disk/mkdir.ts
-import { ResourceName as ResourceName9 } from "@struktoai/mirage-core";
-var mkdirOp = {
-  name: "mkdir",
-  resource: ResourceName9.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9) => {
-    return mkdir2(accessor, path9, true);
-  }
-};
-
-// src/ops/disk/read.ts
-import { ResourceName as ResourceName10 } from "@struktoai/mirage-core";
-var readOp = {
-  name: "read",
-  resource: ResourceName10.DISK,
-  filetype: null,
-  write: false,
-  fn: (accessor, path9) => {
-    return read(accessor, path9);
-  }
-};
-
-// src/ops/disk/read_feather.ts
-import { featherCat, ResourceName as ResourceName11 } from "@struktoai/mirage-core";
-var readFeatherOp = {
-  name: "read",
-  resource: ResourceName11.DISK,
-  filetype: ".feather",
-  write: false,
-  fn: async (accessor, path9) => {
-    const raw = await read(accessor, path9);
-    return featherCat(raw);
-  }
-};
-
-// src/ops/disk/read_hdf5.ts
-import { hdf5Cat, ResourceName as ResourceName12 } from "@struktoai/mirage-core";
-var readHdf5Op = {
-  name: "read",
-  resource: ResourceName12.DISK,
-  filetype: ".hdf5",
-  write: false,
-  fn: async (accessor, path9) => {
-    const raw = await read(accessor, path9);
-    return hdf5Cat(raw);
-  }
-};
-
-// src/ops/disk/read_parquet.ts
-import { parquetCat, ResourceName as ResourceName13 } from "@struktoai/mirage-core";
-var readParquetOp = {
-  name: "read",
-  resource: ResourceName13.DISK,
-  filetype: ".parquet",
-  write: false,
-  fn: async (accessor, path9) => {
-    const raw = await read(accessor, path9);
-    return parquetCat(raw);
-  }
-};
-
-// src/ops/disk/readdir.ts
-import { ResourceName as ResourceName14 } from "@struktoai/mirage-core";
-var readdirOp = {
-  name: "readdir",
-  resource: ResourceName14.DISK,
-  filetype: null,
-  write: false,
-  fn: (accessor, path9) => {
-    return readdir3(accessor, path9);
-  }
-};
-
-// src/ops/disk/rename.ts
-import { ResourceName as ResourceName15 } from "@struktoai/mirage-core";
-var renameOp = {
-  name: "rename",
-  resource: ResourceName15.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9, args) => {
-    const dst = args[0];
-    if (dst === void 0 || dst === null || typeof dst !== "object" || !("original" in dst)) {
-      throw new TypeError("rename op requires a PathSpec destination as the first arg");
-    }
-    return rename(accessor, path9, dst);
-  }
-};
-
-// src/ops/disk/rmdir.ts
-import { ResourceName as ResourceName16 } from "@struktoai/mirage-core";
-var rmdirOp = {
-  name: "rmdir",
-  resource: ResourceName16.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9) => {
-    return rmdir(accessor, path9);
-  }
-};
-
-// src/ops/disk/stat.ts
-import { ResourceName as ResourceName17 } from "@struktoai/mirage-core";
-var statOp = {
-  name: "stat",
-  resource: ResourceName17.DISK,
-  filetype: null,
-  write: false,
-  fn: (accessor, path9) => {
-    return stat(accessor, path9);
-  }
-};
-
-// src/ops/disk/truncate.ts
-import { ResourceName as ResourceName18 } from "@struktoai/mirage-core";
-var truncateOp = {
-  name: "truncate",
-  resource: ResourceName18.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9, args) => {
-    const length = args[0];
-    if (typeof length !== "number") {
-      throw new TypeError("truncate op requires a number length as the first arg");
-    }
-    return truncate(accessor, path9, length);
-  }
-};
-
-// src/ops/disk/unlink.ts
-import { ResourceName as ResourceName19 } from "@struktoai/mirage-core";
-var unlinkOp = {
-  name: "unlink",
-  resource: ResourceName19.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9) => {
-    return unlink(accessor, path9);
-  }
-};
-
-// src/ops/disk/write.ts
-import { extractWriteData } from "@struktoai/mirage-core";
-import { ResourceName as ResourceName20 } from "@struktoai/mirage-core";
-var writeOp = {
-  name: "write",
-  resource: ResourceName20.DISK,
-  filetype: null,
-  write: true,
-  fn: (accessor, path9, args) => {
-    const data = extractWriteData(args);
-    return writeBytes(accessor, path9, data);
-  }
-};
-
 // src/ops/disk/index.ts
-var DISK_OPS = [
-  appendOp,
-  createOp,
-  mkdirOp,
-  readOp,
-  readFeatherOp,
-  readHdf5Op,
-  readParquetOp,
-  readdirOp,
-  renameOp,
-  rmdirOp,
-  statOp,
-  truncateOp,
-  unlinkOp,
-  writeOp
-];
+import { ResourceName as ResourceName6, makeGenericOps } from "@struktoai/mirage-core";
+var DISK_OPS = makeGenericOps(ResourceName6.DISK, DISK_IO, {
+  filetypeRead: [".feather", ".hdf5", ".parquet"],
+  mkdirParents: true,
+  forwardIndex: false
+});
 
 // src/resource/disk/prompt.ts
 var DISK_PROMPT = `{prefix}
@@ -806,6 +609,7 @@ var DISK_PROMPT = `{prefix}
   Standard commands: ls, cat, head, tail, grep, wc, find, tree, mkdir, touch, cp, mv, rm, tee.`;
 
 // src/resource/disk/disk.ts
+var globCore = makeResolveGlob(readdir3, SCOPE_ERROR);
 async function walkFiles(root, current, out) {
   const entries = await readdir4(current, { withFileTypes: true });
   for (const e of entries) {
@@ -818,7 +622,7 @@ async function walkFiles(root, current, out) {
   }
 }
 var DiskResource = class extends BaseResource {
-  kind = ResourceName21.DISK;
+  kind = ResourceName7.DISK;
   cachesReads = false;
   indexTtl = 60;
   prompt = DISK_PROMPT;
@@ -833,7 +637,7 @@ var DiskResource = class extends BaseResource {
     rmdir,
     copy,
     rename,
-    mkdir: mkdir2,
+    mkdir: mkdir4,
     read_stream: stream,
     rm_recursive: rmR,
     du_total: du,
@@ -883,7 +687,7 @@ var DiskResource = class extends BaseResource {
     return exists(this.accessor, p);
   }
   mkdir(p, options) {
-    return mkdir2(this.accessor, p, options?.recursive === true);
+    return mkdir4(this.accessor, p, options?.recursive === true);
   }
   rmdir(p) {
     return rmdir(this.accessor, p);
@@ -909,39 +713,34 @@ var DiskResource = class extends BaseResource {
   find(p, options = {}) {
     return find(this.accessor, p, options);
   }
-  async fingerprint(p) {
-    try {
-      const remote = await stat(this.accessor, p);
-      return remote.modified ?? null;
-    } catch {
-      return null;
-    }
-  }
   glob(paths, prefix = "") {
     const effective = prefix ? paths.map(
-      (p) => p.prefix ? p : new PathSpec2({
-        original: p.original,
+      (p) => mountPrefixOf2(p.virtual, p.resourcePath) ? p : new PathSpec({
+        virtual: p.virtual,
         directory: p.directory,
         ...p.pattern !== null ? { pattern: p.pattern } : {},
         resolved: p.resolved,
-        prefix
+        resourcePath: mountKey(p.virtual, prefix)
       })
     ) : paths;
-    return resolveGlob(this.accessor, effective, this.index);
+    return globCore(this.accessor, effective, this.index);
   }
   async getState() {
     await mkdir5(this.root, { recursive: true });
     const files = {};
+    const modes = {};
     const fileList = [];
     await walkFiles(this.root, this.root, fileList);
     for (const full of fileList) {
       const rel = path8.relative(this.root, full).split(path8.sep).join("/");
       const data = await readFile3(full);
       files[rel] = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      modes[rel] = (await fsStat3(full)).mode & 4095;
     }
     return {
       type: this.kind,
-      files
+      files,
+      modes
     };
   }
   async loadState(state) {
@@ -950,6 +749,8 @@ var DiskResource = class extends BaseResource {
       const full = path8.join(this.root, rel);
       await mkdir5(path8.dirname(full), { recursive: true });
       await writeFile3(full, data);
+      const mode = state.modes?.[rel];
+      if (mode !== void 0) await chmod2(full, mode);
     }
   }
 };
@@ -960,4 +761,4 @@ export {
   DISK_PROMPT,
   DiskResource
 };
-//# sourceMappingURL=chunk-XWVDS66D.js.map
+//# sourceMappingURL=chunk-W5ZLIQFR.js.map