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

package/dist/chunk-WG5YS6TC.js

@@ -0,0 +1,872 @@
+// src/resource/disk/disk.ts
+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 ResourceName8,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf2
+} from "@struktoai/mirage-core";
+
+// src/commands/builtin/disk/index.ts
+import { ResourceName as ResourceName6, makeGenericCommands } 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";
+import { lstripSlash } from "@struktoai/mirage-core";
+import { norm, parent, gnuBasename } from "@struktoai/mirage-core";
+function resolveSafe(root, virtual) {
+  const relative = lstripSlash(virtual);
+  const resolved = path.resolve(root, relative);
+  const rootResolved = path.resolve(root);
+  if (resolved !== rootResolved && !resolved.startsWith(rootResolved + path.sep)) {
+    throw new Error(`path escapes root: ${virtual}`);
+  }
+  return resolved;
+}
+
+// src/core/disk/append.ts
+async function appendBytes(accessor, p, data) {
+  const start = performance.now();
+  const virtual = p.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  try {
+    await appendFile(full, data);
+  } catch (err) {
+    throw diskError(err, p);
+  }
+  record("append", virtual, ResourceName.DISK, data.byteLength, start);
+  await invalidateAfterWrite(p);
+}
+
+// src/core/disk/constants.ts
+var SCOPE_ERROR = 5e4;
+
+// src/core/disk/copy.ts
+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);
+  try {
+    await copyFile(s, d);
+  } catch (err) {
+    let blame = dst;
+    if (err.code === "ENOENT") {
+      const srcMissing = await stat(s).then(
+        () => false,
+        () => true
+      );
+      if (srcMissing) blame = src;
+    }
+    throw diskError(err, blame);
+  }
+  await invalidateAfterWrite2(dst);
+}
+
+// src/core/disk/write.ts
+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);
+  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, path6) {
+  return writeBytes(accessor, path6, new Uint8Array());
+}
+
+// src/core/disk/du/walk.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import path2 from "path";
+async function walkSizes(full) {
+  let total = 0;
+  let st;
+  try {
+    st = await stat2(full);
+  } catch {
+    return 0;
+  }
+  if (st.isFile()) return st.size;
+  if (!st.isDirectory()) return 0;
+  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 {
+        const cst = await stat2(child);
+        total += cst.size;
+      } catch {
+      }
+    }
+  }
+  return total;
+}
+async function walkAll(accessor, full, entries2) {
+  let total = 0;
+  let st;
+  try {
+    st = await stat2(full);
+  } catch {
+    return 0;
+  }
+  if (st.isFile()) {
+    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 = path2.join(full, e.name);
+    if (e.isDirectory()) {
+      total += await walkAll(accessor, child, entries2);
+    } else if (e.isFile()) {
+      try {
+        const cst = await stat2(child);
+        const rel = "/" + path2.relative(accessor.root, child).split(path2.sep).join("/");
+        entries2.push([rel, cst.size]);
+        total += cst.size;
+      } catch {
+      }
+    }
+  }
+  return total;
+}
+
+// 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);
+  const entries2 = [];
+  const total = await walkAll(accessor, full, entries2);
+  entries2.sort((a, b) => compareCodePoints(a[0], b[0]));
+  return [entries2, total];
+}
+
+// src/core/disk/du/size.ts
+async function size(accessor, p) {
+  const virtual = p.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  return walkSizes(full);
+}
+
+// src/core/disk/exists.ts
+import { access } from "fs/promises";
+async function exists(accessor, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
+  try {
+    await access(full);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/disk/find.ts
+import { readdir as readdir2, stat as stat3 } from "fs/promises";
+import path3 from "path";
+import {
+  buildTree,
+  emitStartPath,
+  keep,
+  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 entries2;
+  try {
+    entries2 = await readdir2(full, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries2) {
+    const kind = e.isDirectory() ? "d" : "f";
+    const entryPath = current === "/" ? `/${e.name}` : `${current}/${e.name}`;
+    const entryName = e.name;
+    const entrySlashCount = (entryPath.match(/\//g) ?? []).length;
+    const entryDepth = entrySlashCount - ctx.baseDepth;
+    let accept = true;
+    if (opts.maxDepth !== null && opts.maxDepth !== void 0 && entryDepth > opts.maxDepth) {
+      accept = false;
+    }
+    let isEmpty = null;
+    if (accept && opts.empty === true) {
+      try {
+        isEmpty = kind === "f" ? (await stat3(path3.join(full, e.name))).size === 0 : (await readdir2(path3.join(full, e.name))).length === 0;
+      } catch {
+        isEmpty = null;
+      }
+    }
+    if (accept && !keep(
+      { key: entryPath, name: entryName, kind, depth: entryDepth, isEmpty },
+      ctx.tree,
+      opts.minDepth
+    )) {
+      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(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)
+          accept = false;
+        if (accept && (opts.mtimeMin !== void 0 || opts.mtimeMax !== void 0)) {
+          const mtime = st.mtime.getTime() / 1e3;
+          if (opts.mtimeMin !== null && opts.mtimeMin !== void 0 && mtime < opts.mtimeMin)
+            accept = false;
+          if (opts.mtimeMax !== null && opts.mtimeMax !== void 0 && mtime > opts.mtimeMax)
+            accept = false;
+        }
+      } catch {
+        accept = false;
+      }
+    }
+    if (accept) ctx.results.push(entryPath);
+    if (kind === "d") {
+      await walk(ctx, path3.join(full, e.name), entryPath, depth + 1);
+    }
+  }
+}
+async function find(accessor, p, options = {}) {
+  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 = [];
+  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
+  });
+  if (options.maxDepth == null || options.maxDepth >= 0) {
+    let isDir = false;
+    try {
+      isDir = (await stat3(full)).isDirectory();
+    } catch {
+      isDir = false;
+    }
+    let rootEmpty = null;
+    if (isDir && options.empty === true) {
+      try {
+        rootEmpty = (await readdir2(full)).length === 0;
+      } catch {
+        rootEmpty = null;
+      }
+    }
+    emitStartPath(results, virtual, startName, {
+      kind: "d",
+      isEmpty: rootEmpty,
+      exists: isDir,
+      tree,
+      maxDepth: options.maxDepth,
+      minDepth: options.minDepth,
+      minSize: options.minSize,
+      maxSize: options.maxSize
+    });
+  }
+  await walk({ accessor, base: virtual, baseDepth, options, tree, results }, full, virtual, 0);
+  results.sort(compareCodePoints2);
+  return results;
+}
+
+// src/core/disk/mkdir.ts
+import { mkdir as fsMkdir } from "fs/promises";
+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) {
+    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) {
+    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);
+    }
+    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();
+  }
+}
+
+// src/core/disk/readdir.ts
+import { readdir as fsReaddir } from "fs/promises";
+import {
+  IndexEntry,
+  ResourceType,
+  enoent as enoent2,
+  enotdir as enotdir2,
+  mountPrefixOf,
+  rstripSlash,
+  compareCodePoints as compareCodePoints3
+} from "@struktoai/mirage-core";
+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);
+    if (cached.entries !== void 0 && cached.entries !== null) {
+      return cached.entries;
+    }
+  }
+  const full = resolveSafe(accessor.root, virtual);
+  let entries2;
+  try {
+    entries2 = await fsReaddir(full);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOTDIR") throw enotdir2(path6);
+    if (code === "ENOENT") throw enoent2(path6);
+    throw err;
+  }
+  const base = norm(virtual);
+  const dirPrefix = base === "/" ? "/" : `${base}/`;
+  const sorted = [...entries2].sort(compareCodePoints3);
+  const virtualEntries = sorted.map((e) => `${mountPrefix}${dirPrefix}${e}`);
+  if (index !== void 0) {
+    const indexEntries = sorted.map((name) => [
+      name,
+      new IndexEntry({
+        id: `${dirPrefix}${name}`,
+        name,
+        resourceType: ResourceType.FILE
+      })
+    ]);
+    await index.setDir(virtualKey, indexEntries);
+  }
+  return virtualEntries;
+}
+
+// src/core/disk/rename.ts
+import { rename as fsRename } from "fs/promises";
+import {
+  enoent as enoent3,
+  invalidateAfterUnlink,
+  invalidateAfterWrite as invalidateAfterWrite5
+} from "@struktoai/mirage-core";
+async function rename(accessor, src, dst) {
+  const s = resolveSafe(accessor.root, src.mountPath);
+  const d = resolveSafe(accessor.root, dst.mountPath);
+  try {
+    await fsRename(s, d);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw enoent3(src);
+    }
+    throw err;
+  }
+  await invalidateAfterUnlink(src);
+  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, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
+  await rm(full, { recursive: true, force: true });
+  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, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
+  try {
+    await fsRmdir(full);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+  await invalidateAfterUnlink3(path6);
+}
+
+// src/core/disk/set_attrs.ts
+import { chmod, stat as fsStat2, utimes } from "fs/promises";
+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 enoent4(path6);
+    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/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 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 });
+  try {
+    for await (const chunk of rs) {
+      const buf = chunk;
+      const u8 = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+      if (rec !== null) rec.bytes += u8.byteLength;
+      yield u8;
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw enoent5(path6);
+    }
+    throw err;
+  }
+}
+
+// src/core/disk/truncate.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+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);
+  } 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);
+  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, path6) {
+  const full = resolveSafe(accessor.root, path6.mountPath);
+  try {
+    await fsUnlink(full);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+  await invalidateAfterUnlink4(path6);
+}
+
+// src/commands/builtin/disk/io.ts
+var DISK_IO = {
+  readdir: readdir3,
+  readBytes: read,
+  readRange,
+  readStream: stream,
+  stat: stat4,
+  isMounted: (a) => a.root !== "",
+  local: true,
+  maxGlobMatches: SCOPE_ERROR,
+  write: writeBytes,
+  exists,
+  mkdir,
+  unlink,
+  rmdir,
+  rmR,
+  rename,
+  copy,
+  create,
+  truncate,
+  append: appendBytes,
+  setAttrs,
+  find,
+  du: { size, entries }
+};
+
+// src/commands/builtin/disk/index.ts
+var DISK_COMMANDS = [
+  ...makeGenericCommands(ResourceName6.DISK, DISK_IO)
+];
+
+// src/accessor/disk.ts
+import { Accessor } from "@struktoai/mirage-core";
+var DiskAccessor = class extends Accessor {
+  root;
+  constructor(root) {
+    super();
+    this.root = root;
+  }
+};
+
+// src/ops/disk/index.ts
+import { ResourceName as ResourceName7, makeGenericOps } from "@struktoai/mirage-core";
+var DISK_OPS = makeGenericOps(ResourceName7.DISK, DISK_IO, {
+  mkdirParents: true
+});
+
+// src/resource/disk/prompt.ts
+var DISK_PROMPT = `{prefix}
+  Local disk filesystem. Mirrors the configured root directory.
+  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 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()) {
+      out.push(child);
+    }
+  }
+}
+var DiskResource = class extends BaseResource {
+  kind = ResourceName8.DISK;
+  cachesReads = false;
+  // byte store: stat() sizes every file from metadata
+  sizesAlwaysKnown = true;
+  indexTtl = 60;
+  prompt = DISK_PROMPT;
+  root;
+  accessor;
+  opsMap = {
+    read_bytes: read,
+    write: writeBytes,
+    readdir: readdir3,
+    stat: stat4,
+    unlink,
+    rmdir,
+    copy,
+    rename,
+    mkdir,
+    read_stream: stream,
+    rm_recursive: rmR,
+    du_size: size,
+    du_entries: entries,
+    create,
+    truncate,
+    exists,
+    find_flat: find,
+    append: appendBytes
+  };
+  constructor(options) {
+    super();
+    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 mkdir2(this.root, { recursive: true });
+  }
+  // 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;
+  }
+  commands() {
+    return DISK_COMMANDS;
+  }
+  streamPath(p) {
+    return stream(this.accessor, p);
+  }
+  readFile(p) {
+    return read(this.accessor, p);
+  }
+  writeFile(p, data) {
+    return writeBytes(this.accessor, p, data);
+  }
+  appendFile(p, data) {
+    return appendBytes(this.accessor, p, data);
+  }
+  readdir(p) {
+    return readdir3(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return stat4(this.accessor, p);
+  }
+  exists(p) {
+    return exists(this.accessor, p);
+  }
+  mkdir(p, options) {
+    return mkdir(this.accessor, p, options?.recursive === true);
+  }
+  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 size(this.accessor, p);
+  }
+  find(p, options = {}) {
+    return find(this.accessor, p, options);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix ? paths.map(
+      (p) => mountPrefixOf2(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);
+  }
+  async getState() {
+    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 = 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 fsStat4(full)).mode & 4095;
+    }
+    return {
+      type: this.kind,
+      files,
+      modes
+    };
+  }
+  async loadState(state) {
+    await mkdir2(this.root, { recursive: true });
+    for (const [rel, data] of Object.entries(state.files)) {
+      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);
+    }
+  }
+};
+
+export {
+  DISK_COMMANDS,
+  DISK_OPS,
+  DISK_PROMPT,
+  DiskResource
+};
+//# sourceMappingURL=chunk-WG5YS6TC.js.map