@struktoai/mirage-node 0.0.4 → 0.0.5

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

@@ -1,25 +1,40 @@
 // src/resource/disk/disk.ts
-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 {
+  chmod as chmod2,
+  mkdir as mkdir2,
+  readdir as readdir4,
+  readFile as readFile3,
+  stat as fsStat4,
+  statfs as fsStatfs,
+  writeFile as writeFile3
+} from "fs/promises";
+import path5 from "path";
 import {
   BaseResource,
+  CapacityState,
   PathSpec,
-  ResourceName as ResourceName7,
+  ResourceName as ResourceName8,
   makeResolveGlob,
   mountKey,
   mountPrefixOf as mountPrefixOf2
 } from "@struktoai/mirage-core";
 
 // src/commands/builtin/disk/index.ts
-import {
-  ResourceName as ResourceName5,
-  makeFiletypeCommands,
-  makeGenericCommands
-} from "@struktoai/mirage-core";
+import { ResourceName as ResourceName6, makeGenericCommands } from "@struktoai/mirage-core";
 
-// src/core/disk/read.ts
-import { readFile } from "fs/promises";
-import { enoent, record, ResourceName } from "@struktoai/mirage-core";
+// src/core/disk/append.ts
+import { appendFile } from "fs/promises";
+import { ResourceName, invalidateAfterWrite, record } from "@struktoai/mirage-core";
+
+// src/core/disk/errors.ts
+function diskError(err, spec) {
+  const code = err.code;
+  if (typeof code !== "string") return err;
+  const out = new Error(spec.virtual);
+  out.code = code;
+  out.virtualPath = spec.virtual;
+  return out;
+}
 
 // src/core/disk/utils.ts
 import path from "path";
@@ -35,74 +50,17 @@ function resolveSafe(root, virtual) {
   return resolved;
 }
 
-// src/core/disk/read.ts
-async function read(accessor, path9) {
+// src/core/disk/append.ts
+async function appendBytes(accessor, p, data) {
   const start = performance.now();
-  const virtual = path9.mountPath;
-  const full = resolveSafe(accessor.root, virtual);
-  let data;
-  try {
-    data = await readFile(full);
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      throw enoent(path9);
-    }
-    throw err;
-  }
-  record("read", virtual, ResourceName.DISK, data.byteLength, start);
-  return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-}
-
-// src/core/disk/stat.ts
-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.mountPath;
   const full = resolveSafe(accessor.root, virtual);
-  let st;
   try {
-    st = await fsStat(full);
+    await appendFile(full, data);
   } catch (err) {
-    if (err.code === "ENOENT") {
-      throw enoent2(p);
-    }
-    throw err;
+    throw diskError(err, p);
   }
-  const modified = st.mtime.toISOString();
-  const name = path2.basename(full);
-  if (st.isDirectory()) {
-    return new FileStat({
-      name,
-      size: null,
-      modified,
-      type: FileType.DIRECTORY,
-      mode: st.mode & 4095,
-      atime: st.atime.toISOString()
-    });
-  }
-  return new FileStat({
-    name,
-    size: st.size,
-    modified,
-    fingerprint: modified,
-    type: guessType(name),
-    mode: st.mode & 4095,
-    atime: st.atime.toISOString()
-  });
-}
-
-// src/core/disk/append.ts
-import { appendFile, mkdir } from "fs/promises";
-import path3 from "path";
-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);
+  record("append", virtual, ResourceName.DISK, data.byteLength, start);
   await invalidateAfterWrite(p);
 }
 
@@ -110,46 +68,51 @@ async function appendBytes(accessor, p, data) {
 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";
+import { copyFile, stat } from "fs/promises";
+import { invalidateAfterWrite as invalidateAfterWrite2 } from "@struktoai/mirage-core";
 async function copy(accessor, src, dst) {
   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) {
+    let blame = dst;
     if (err.code === "ENOENT") {
-      throw enoent3(src);
+      const srcMissing = await stat(s).then(
+        () => false,
+        () => true
+      );
+      if (srcMissing) blame = src;
     }
-    throw err;
+    throw diskError(err, blame);
   }
   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";
+import { writeFile } from "fs/promises";
+import { ResourceName as ResourceName2, invalidateAfterWrite as invalidateAfterWrite3, record as record2 } 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);
+  try {
+    await writeFile(full, data);
+  } catch (err) {
+    throw diskError(err, p);
+  }
+  record2("write", virtual, ResourceName2.DISK, data.byteLength, start);
   await invalidateAfterWrite3(p);
 }
 
 // src/core/disk/create.ts
-function create(accessor, path9) {
-  return writeBytes(accessor, path9, new Uint8Array());
+function create(accessor, path6) {
+  return writeBytes(accessor, path6, new Uint8Array());
 }
 
-// src/core/disk/du.ts
+// src/core/disk/du/walk.ts
 import { readdir, stat as stat2 } from "fs/promises";
-import path6 from "path";
+import path2 from "path";
 async function walkSizes(full) {
   let total = 0;
   let st;
@@ -160,9 +123,9 @@ async function walkSizes(full) {
   }
   if (st.isFile()) return st.size;
   if (!st.isDirectory()) return 0;
-  const entries = await readdir(full, { withFileTypes: true });
-  for (const e of entries) {
-    const child = path6.join(full, e.name);
+  const entries2 = await readdir(full, { withFileTypes: true });
+  for (const e of entries2) {
+    const child = path2.join(full, e.name);
     if (e.isDirectory()) total += await walkSizes(child);
     else if (e.isFile()) {
       try {
@@ -174,7 +137,7 @@ async function walkSizes(full) {
   }
   return total;
 }
-async function walkAll(accessor, full, entries) {
+async function walkAll(accessor, full, entries2) {
   let total = 0;
   let st;
   try {
@@ -183,21 +146,21 @@ async function walkAll(accessor, full, entries) {
     return 0;
   }
   if (st.isFile()) {
-    const rel = "/" + path6.relative(accessor.root, full).split(path6.sep).join("/");
-    entries.push([rel, st.size]);
+    const rel = "/" + path2.relative(accessor.root, full).split(path2.sep).join("/");
+    entries2.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 = path6.join(full, e.name);
+    const child = path2.join(full, e.name);
     if (e.isDirectory()) {
-      total += await walkAll(accessor, child, entries);
+      total += await walkAll(accessor, child, entries2);
     } else if (e.isFile()) {
       try {
         const cst = await stat2(child);
-        const rel = "/" + path6.relative(accessor.root, child).split(path6.sep).join("/");
-        entries.push([rel, cst.size]);
+        const rel = "/" + path2.relative(accessor.root, child).split(path2.sep).join("/");
+        entries2.push([rel, cst.size]);
         total += cst.size;
       } catch {
       }
@@ -205,24 +168,29 @@ async function walkAll(accessor, full, entries) {
   }
   return total;
 }
-async function du(accessor, p) {
-  const virtual = p.mountPath;
+
+// src/core/disk/du/entries.ts
+import { compareCodePoints } from "@struktoai/mirage-core";
+async function entries(accessor, p) {
+  const virtual = norm(p.mountPath);
   const full = resolveSafe(accessor.root, virtual);
-  return walkSizes(full);
+  const entries2 = [];
+  const total = await walkAll(accessor, full, entries2);
+  entries2.sort((a, b) => compareCodePoints(a[0], b[0]));
+  return [entries2, total];
 }
-async function duAll(accessor, p) {
-  const virtual = norm(p.mountPath);
+
+// src/core/disk/du/size.ts
+async function size(accessor, p) {
+  const virtual = p.mountPath;
   const full = resolveSafe(accessor.root, virtual);
-  const entries = [];
-  const total = await walkAll(accessor, full, entries);
-  entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
-  return [entries, total];
+  return walkSizes(full);
 }
 
 // src/core/disk/exists.ts
 import { access } from "fs/promises";
-async function exists(accessor, path9) {
-  const full = resolveSafe(accessor.root, path9.mountPath);
+async function exists(accessor, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
   try {
     await access(full);
     return true;
@@ -233,23 +201,24 @@ async function exists(accessor, path9) {
 
 // src/core/disk/find.ts
 import { readdir as readdir2, stat as stat3 } from "fs/promises";
-import path7 from "path";
+import path3 from "path";
 import {
   buildTree,
   emitStartPath,
   keep,
-  startBasename
+  startBasename,
+  compareCodePoints as compareCodePoints2
 } from "@struktoai/mirage-core";
 async function walk(ctx, full, current, depth) {
   const opts = ctx.options;
   if (opts.maxDepth !== null && opts.maxDepth !== void 0 && depth > opts.maxDepth) return;
-  let entries;
+  let entries2;
   try {
-    entries = await readdir2(full, { withFileTypes: true });
+    entries2 = await readdir2(full, { withFileTypes: true });
   } catch {
     return;
   }
-  for (const e of entries) {
+  for (const e of entries2) {
     const kind = e.isDirectory() ? "d" : "f";
     const entryPath = current === "/" ? `/${e.name}` : `${current}/${e.name}`;
     const entryName = e.name;
@@ -262,7 +231,7 @@ async function walk(ctx, full, current, depth) {
     let isEmpty = null;
     if (accept && opts.empty === true) {
       try {
-        isEmpty = kind === "f" ? (await stat3(path7.join(full, e.name))).size === 0 : (await readdir2(path7.join(full, e.name))).length === 0;
+        isEmpty = kind === "f" ? (await stat3(path3.join(full, e.name))).size === 0 : (await readdir2(path3.join(full, e.name))).length === 0;
       } catch {
         isEmpty = null;
       }
@@ -280,7 +249,7 @@ async function walk(ctx, full, current, depth) {
     }
     if (accept && kind === "f" && (opts.minSize !== null || opts.maxSize !== null || opts.mtimeMin !== null || opts.mtimeMax !== null)) {
       try {
-        const st = await stat3(path7.join(full, e.name));
+        const st = await stat3(path3.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)
@@ -298,7 +267,7 @@ async function walk(ctx, full, current, depth) {
     }
     if (accept) ctx.results.push(entryPath);
     if (kind === "d") {
-      await walk(ctx, path7.join(full, e.name), entryPath, depth + 1);
+      await walk(ctx, path3.join(full, e.name), entryPath, depth + 1);
     }
   }
 }
@@ -344,31 +313,118 @@ async function find(accessor, p, options = {}) {
     });
   }
   await walk({ accessor, base: virtual, baseDepth, options, tree, results }, full, virtual, 0);
-  results.sort();
+  results.sort(compareCodePoints2);
   return results;
 }
 
 // src/core/disk/mkdir.ts
 import { mkdir as fsMkdir } from "fs/promises";
-import { invalidateAfterWrite as invalidateAfterWrite4, invalidateAncestors } from "@struktoai/mirage-core";
-async function mkdir4(accessor, path9, parents = false) {
-  const full = resolveSafe(accessor.root, path9.mountPath);
+import {
+  invalidateAfterWrite as invalidateAfterWrite4,
+  invalidateAncestors,
+  norm as norm2
+} from "@struktoai/mirage-core";
+
+// src/core/disk/dest.ts
+import { stat as fsStat } from "fs/promises";
+import {
+  ancestors,
+  enotdir,
+  mountedPath
+} from "@struktoai/mirage-core";
+async function mkdirComponentError(root, spec, key) {
+  for (const component of ancestors(key)) {
+    try {
+      const st = await fsStat(resolveSafe(root, component));
+      if (!st.isDirectory()) return enotdir(mountedPath(spec, component));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/core/disk/mkdir.ts
+async function mkdir(accessor, path6, parents = false) {
+  const root = accessor.root;
+  const full = resolveSafe(root, path6.mountPath);
   if (parents) {
-    await fsMkdir(full, { recursive: true });
-    await invalidateAfterWrite4(path9);
-    await invalidateAncestors(path9);
+    try {
+      await fsMkdir(full, { recursive: true });
+    } catch (err) {
+      const named = err.code === "ENOTDIR" ? await mkdirComponentError(root, path6, norm2(path6.mountPath)) : null;
+      throw named ?? diskError(err, path6);
+    }
+    await invalidateAfterWrite4(path6);
+    await invalidateAncestors(path6);
     return;
   }
   try {
     await fsMkdir(full);
   } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") {
-      throw new Error(`parent directory does not exist: ${path9.mountPath}`);
+    throw diskError(err, path6);
+  }
+  await invalidateAfterWrite4(path6);
+}
+
+// src/core/disk/read.ts
+import { open, readFile } from "fs/promises";
+import { enoent, record as record3, ResourceName as ResourceName3 } from "@struktoai/mirage-core";
+var CHUNK = 1 << 20;
+async function read(accessor, path6) {
+  const start = performance.now();
+  const virtual = path6.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  let data;
+  try {
+    data = await readFile(full);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw enoent(path6);
     }
-    if (code !== "EEXIST") throw err;
+    throw err;
+  }
+  record3("read", virtual, ResourceName3.DISK, data.byteLength, start);
+  return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+async function readRange(accessor, path6, _index, offset, size2) {
+  const start = performance.now();
+  const virtual = path6.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  let handle;
+  try {
+    handle = await open(full, "r");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw enoent(path6);
+    }
+    throw err;
+  }
+  try {
+    if (size2 !== null) {
+      const buf = Buffer.allocUnsafe(size2);
+      const { bytesRead } = await handle.read(buf, 0, size2, offset);
+      const out = new Uint8Array(buf.buffer, buf.byteOffset, bytesRead);
+      record3("read", virtual, ResourceName3.DISK, bytesRead, start);
+      return out;
+    }
+    const parts = [];
+    let total = 0;
+    let at = offset;
+    for (; ; ) {
+      const buf = Buffer.allocUnsafe(CHUNK);
+      const { bytesRead } = await handle.read(buf, 0, CHUNK, at);
+      if (bytesRead === 0) break;
+      parts.push(buf.subarray(0, bytesRead));
+      total += bytesRead;
+      at += bytesRead;
+    }
+    const joined = Buffer.concat(parts, total);
+    record3("read", virtual, ResourceName3.DISK, total, start);
+    return new Uint8Array(joined.buffer, joined.byteOffset, joined.byteLength);
+  } finally {
+    await handle.close();
   }
-  await invalidateAfterWrite4(path9);
 }
 
 // src/core/disk/readdir.ts
@@ -376,13 +432,15 @@ import { readdir as fsReaddir } from "fs/promises";
 import {
   IndexEntry,
   ResourceType,
-  enotdir,
+  enoent as enoent2,
+  enotdir as enotdir2,
   mountPrefixOf,
-  rstripSlash
+  rstripSlash,
+  compareCodePoints as compareCodePoints3
 } from "@struktoai/mirage-core";
-async function readdir3(accessor, path9, index) {
-  const virtual = path9.pattern !== null ? path9.directory : path9.mountPath;
-  const mountPrefix = mountPrefixOf(path9.virtual, path9.resourcePath);
+async function readdir3(accessor, path6, index) {
+  const virtual = path6.pattern !== null ? path6.directory : path6.mountPath;
+  const mountPrefix = mountPrefixOf(path6.virtual, path6.resourcePath);
   const virtualKey = rstripSlash(mountPrefix + virtual) || "/";
   if (index !== void 0) {
     const cached = await index.listDir(virtualKey);
@@ -391,18 +449,18 @@ async function readdir3(accessor, path9, index) {
     }
   }
   const full = resolveSafe(accessor.root, virtual);
-  let entries;
+  let entries2;
   try {
-    entries = await fsReaddir(full);
+    entries2 = await fsReaddir(full);
   } catch (err) {
     const code = err.code;
-    if (code === "ENOTDIR") throw enotdir(path9);
-    if (code === "ENOENT") throw enotdir(path9);
+    if (code === "ENOTDIR") throw enotdir2(path6);
+    if (code === "ENOENT") throw enoent2(path6);
     throw err;
   }
   const base = norm(virtual);
   const dirPrefix = base === "/" ? "/" : `${base}/`;
-  const sorted = [...entries].sort();
+  const sorted = [...entries2].sort(compareCodePoints3);
   const virtualEntries = sorted.map((e) => `${mountPrefix}${dirPrefix}${e}`);
   if (index !== void 0) {
     const indexEntries = sorted.map((name) => [
@@ -421,7 +479,7 @@ async function readdir3(accessor, path9, index) {
 // src/core/disk/rename.ts
 import { rename as fsRename } from "fs/promises";
 import {
-  enoent as enoent4,
+  enoent as enoent3,
   invalidateAfterUnlink,
   invalidateAfterWrite as invalidateAfterWrite5
 } from "@struktoai/mirage-core";
@@ -432,7 +490,7 @@ async function rename(accessor, src, dst) {
     await fsRename(s, d);
   } catch (err) {
     if (err.code === "ENOENT") {
-      throw enoent4(src);
+      throw enoent3(src);
     }
     throw err;
   }
@@ -443,36 +501,36 @@ async function rename(accessor, src, 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.mountPath);
+async function rmR(accessor, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
   await rm(full, { recursive: true, force: true });
-  await invalidateAfterUnlink2(path9);
+  await invalidateAfterUnlink2(path6);
 }
 
 // src/core/disk/rmdir.ts
 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.mountPath);
+async function rmdir(accessor, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
   try {
     await fsRmdir(full);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
   }
-  await invalidateAfterUnlink3(path9);
+  await invalidateAfterUnlink3(path6);
 }
 
 // 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);
+import { enoent as enoent4 } from "@struktoai/mirage-core";
+async function setAttrs(accessor, path6, fields) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
   let st;
   try {
     st = await fsStat2(full);
   } catch (err) {
-    if (err.code === "ENOENT") throw enoent5(path9);
+    if (err.code === "ENOENT") throw enoent4(path6);
     throw err;
   }
   const residual = {};
@@ -491,11 +549,47 @@ async function setAttrs(accessor, path9, fields) {
   return residual;
 }
 
+// src/core/disk/stat.ts
+import { stat as fsStat3 } from "fs/promises";
+import path4 from "path";
+import { FileStat, FileType, guessType } from "@struktoai/mirage-core";
+async function stat4(accessor, p) {
+  const virtual = p.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  let st;
+  try {
+    st = await fsStat3(full);
+  } catch (err) {
+    throw diskError(err, p);
+  }
+  const modified = st.mtime.toISOString();
+  const name = path4.basename(full);
+  if (st.isDirectory()) {
+    return new FileStat({
+      name,
+      size: null,
+      modified,
+      type: FileType.DIRECTORY,
+      mode: st.mode & 4095,
+      atime: st.atime.toISOString()
+    });
+  }
+  return new FileStat({
+    name,
+    size: st.size,
+    modified,
+    fingerprint: modified,
+    type: guessType(name),
+    mode: st.mode & 4095,
+    atime: st.atime.toISOString()
+  });
+}
+
 // src/core/disk/stream.ts
 import { createReadStream } from "fs";
-import { enoent as enoent6, recordStream, ResourceName as ResourceName4 } from "@struktoai/mirage-core";
-async function* stream(accessor, path9) {
-  const virtual = path9.mountPath;
+import { enoent as enoent5, recordStream, ResourceName as ResourceName4 } from "@struktoai/mirage-core";
+async function* stream(accessor, path6) {
+  const virtual = path6.mountPath;
   const full = resolveSafe(accessor.root, virtual);
   const rec = recordStream("read", virtual, ResourceName4.DISK);
   const rs = createReadStream(full, { highWaterMark: 65536 });
@@ -508,7 +602,7 @@ async function* stream(accessor, path9) {
     }
   } catch (err) {
     if (err.code === "ENOENT") {
-      throw enoent6(path9);
+      throw enoent5(path6);
     }
     throw err;
   }
@@ -516,9 +610,10 @@ async function* stream(accessor, path9) {
 
 // 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);
+import { ResourceName as ResourceName5, invalidateAfterWrite as invalidateAfterWrite6, record as record4 } from "@struktoai/mirage-core";
+async function truncate(accessor, path6, length) {
+  const start = performance.now();
+  const full = resolveSafe(accessor.root, path6.mountPath);
   let data;
   try {
     data = await readFile2(full);
@@ -532,35 +627,37 @@ async function truncate(accessor, path9, length) {
   const out = new Uint8Array(length);
   out.set(data.subarray(0, Math.min(data.byteLength, length)));
   await writeFile2(full, out);
-  await invalidateAfterWrite6(path9);
+  record4("truncate", path6.mountPath, ResourceName5.DISK, 0, start);
+  await invalidateAfterWrite6(path6);
 }
 
 // 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.mountPath);
+async function unlink(accessor, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
   try {
     await fsUnlink(full);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
   }
-  await invalidateAfterUnlink4(path9);
+  await invalidateAfterUnlink4(path6);
 }
 
 // src/commands/builtin/disk/io.ts
 var DISK_IO = {
   readdir: readdir3,
   readBytes: read,
+  readRange,
   readStream: stream,
-  stat,
+  stat: stat4,
   isMounted: (a) => a.root !== "",
   local: true,
   maxGlobMatches: SCOPE_ERROR,
   write: writeBytes,
   exists,
-  mkdir: mkdir4,
+  mkdir,
   unlink,
   rmdir,
   rmR,
@@ -571,18 +668,12 @@ var DISK_IO = {
   append: appendBytes,
   setAttrs,
   find,
-  duTotal: du,
-  duAll
+  du: { size, entries }
 };
 
 // src/commands/builtin/disk/index.ts
 var DISK_COMMANDS = [
-  ...makeFiletypeCommands({
-    resource: ResourceName5.DISK,
-    readBytes: read,
-    statEntry: stat
-  }),
-  ...makeGenericCommands(ResourceName5.DISK, DISK_IO)
+  ...makeGenericCommands(ResourceName6.DISK, DISK_IO)
 ];
 
 // src/accessor/disk.ts
@@ -596,11 +687,9 @@ var DiskAccessor = class extends Accessor {
 };
 
 // src/ops/disk/index.ts
-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
+import { ResourceName as ResourceName7, makeGenericOps } from "@struktoai/mirage-core";
+var DISK_OPS = makeGenericOps(ResourceName7.DISK, DISK_IO, {
+  mkdirParents: true
 });
 
 // src/resource/disk/prompt.ts
@@ -611,9 +700,9 @@ var DISK_PROMPT = `{prefix}
 // 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) {
-    const child = path8.join(current, e.name);
+  const entries2 = await readdir4(current, { withFileTypes: true });
+  for (const e of entries2) {
+    const child = path5.join(current, e.name);
     if (e.isDirectory()) {
       await walkFiles(root, child, out);
     } else if (e.isFile()) {
@@ -622,8 +711,10 @@ async function walkFiles(root, current, out) {
   }
 }
 var DiskResource = class extends BaseResource {
-  kind = ResourceName7.DISK;
+  kind = ResourceName8.DISK;
   cachesReads = false;
+  // byte store: stat() sizes every file from metadata
+  sizesAlwaysKnown = true;
   indexTtl = 60;
   prompt = DISK_PROMPT;
   root;
@@ -632,16 +723,16 @@ var DiskResource = class extends BaseResource {
     read_bytes: read,
     write: writeBytes,
     readdir: readdir3,
-    stat,
+    stat: stat4,
     unlink,
     rmdir,
     copy,
     rename,
-    mkdir: mkdir4,
+    mkdir,
     read_stream: stream,
     rm_recursive: rmR,
-    du_total: du,
-    du_all: duAll,
+    du_size: size,
+    du_entries: entries,
     create,
     truncate,
     exists,
@@ -650,14 +741,31 @@ var DiskResource = class extends BaseResource {
   };
   constructor(options) {
     super();
-    this.root = path8.resolve(options.root);
+    this.root = path5.resolve(options.root);
     this.accessor = new DiskAccessor(this.root);
   }
+  // The resolved root is the storage: two DiskResources built on the same
+  // directory are one store, however they were spelled.
+  storageId() {
+    return `${this.kind}:${this.root}`;
+  }
   async open() {
-    await mkdir5(this.root, { recursive: true });
+    await mkdir2(this.root, { recursive: true });
   }
-  close() {
-    return Promise.resolve();
+  // A real filesystem reports real numbers (QUOTA). GNU df: used counts
+  // reserved blocks (blocks - bfree), available excludes them (bavail).
+  async statfs() {
+    const st = await fsStatfs(this.root);
+    const bsize = st.bsize;
+    return {
+      state: CapacityState.QUOTA,
+      total: st.blocks * bsize,
+      used: (st.blocks - st.bfree) * bsize,
+      available: st.bavail * bsize,
+      inodes: st.files,
+      inodesUsed: st.files - st.ffree,
+      inodesFree: st.ffree
+    };
   }
   ops() {
     return DISK_OPS;
@@ -681,13 +789,13 @@ var DiskResource = class extends BaseResource {
     return readdir3(this.accessor, p, this.index);
   }
   stat(p) {
-    return stat(this.accessor, p);
+    return stat4(this.accessor, p);
   }
   exists(p) {
     return exists(this.accessor, p);
   }
   mkdir(p, options) {
-    return mkdir4(this.accessor, p, options?.recursive === true);
+    return mkdir(this.accessor, p, options?.recursive === true);
   }
   rmdir(p) {
     return rmdir(this.accessor, p);
@@ -708,7 +816,7 @@ var DiskResource = 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);
@@ -726,16 +834,16 @@ var DiskResource = class extends BaseResource {
     return globCore(this.accessor, effective, this.index);
   }
   async getState() {
-    await mkdir5(this.root, { recursive: true });
+    await mkdir2(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 rel = path5.relative(this.root, full).split(path5.sep).join("/");
       const data = await readFile3(full);
       files[rel] = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-      modes[rel] = (await fsStat3(full)).mode & 4095;
+      modes[rel] = (await fsStat4(full)).mode & 4095;
     }
     return {
       type: this.kind,
@@ -744,10 +852,10 @@ var DiskResource = class extends BaseResource {
     };
   }
   async loadState(state) {
-    await mkdir5(this.root, { recursive: true });
+    await mkdir2(this.root, { recursive: true });
     for (const [rel, data] of Object.entries(state.files)) {
-      const full = path8.join(this.root, rel);
-      await mkdir5(path8.dirname(full), { recursive: true });
+      const full = path5.join(this.root, rel);
+      await mkdir2(path5.dirname(full), { recursive: true });
       await writeFile3(full, data);
       const mode = state.modes?.[rel];
       if (mode !== void 0) await chmod2(full, mode);
@@ -761,4 +869,4 @@ export {
   DISK_PROMPT,
   DiskResource
 };
-//# sourceMappingURL=chunk-W5ZLIQFR.js.map
+//# sourceMappingURL=chunk-WG5YS6TC.js.map