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

package/dist/chunk-WG5YS6TC.js

@@ -1,872 +0,0 @@
-// 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