@struktoai/mirage-node 0.0.3-alpha.0 → 0.0.4

package/dist/chunk-W5ZLIQFR.js

@@ -0,0 +1,764 @@
+// 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 {
+  BaseResource,
+  PathSpec,
+  ResourceName as ResourceName7,
+  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";
+
+// src/core/disk/read.ts
+import { readFile } from "fs/promises";
+import { enoent, record, ResourceName } from "@struktoai/mirage-core";
+
+// 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/read.ts
+async function read(accessor, path9) {
+  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);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw enoent2(p);
+    }
+    throw err;
+  }
+  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);
+  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.mountPath);
+  const d = resolveSafe(accessor.root, dst.mountPath);
+  await mkdir2(path4.dirname(d), { recursive: true });
+  try {
+    await copyFile(s, d);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw enoent3(src);
+    }
+    throw err;
+  }
+  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 path6 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 entries = await readdir(full, { withFileTypes: true });
+  for (const e of entries) {
+    const child = path6.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, entries) {
+  let total = 0;
+  let st;
+  try {
+    st = await stat2(full);
+  } catch {
+    return 0;
+  }
+  if (st.isFile()) {
+    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 = 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 = "/" + path6.relative(accessor.root, child).split(path6.sep).join("/");
+        entries.push([rel, cst.size]);
+        total += cst.size;
+      } catch {
+      }
+    }
+  }
+  return total;
+}
+async function du(accessor, p) {
+  const virtual = p.mountPath;
+  const full = resolveSafe(accessor.root, virtual);
+  return walkSizes(full);
+}
+async function duAll(accessor, p) {
+  const virtual = norm(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];
+}
+
+// src/core/disk/exists.ts
+import { access } from "fs/promises";
+async function exists(accessor, path9) {
+  const full = resolveSafe(accessor.root, path9.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 path7 from "path";
+import {
+  buildTree,
+  emitStartPath,
+  keep,
+  startBasename
+} 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;
+  try {
+    entries = await readdir2(full, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    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(path7.join(full, e.name))).size === 0 : (await readdir2(path7.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(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)
+          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, path7.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();
+  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);
+  if (parents) {
+    await fsMkdir(full, { recursive: true });
+    await invalidateAfterWrite4(path9);
+    await invalidateAncestors(path9);
+    return;
+  }
+  try {
+    await fsMkdir(full);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`parent directory does not exist: ${path9.mountPath}`);
+    }
+    if (code !== "EEXIST") throw err;
+  }
+  await invalidateAfterWrite4(path9);
+}
+
+// src/core/disk/readdir.ts
+import { readdir as fsReaddir } from "fs/promises";
+import {
+  IndexEntry,
+  ResourceType,
+  enotdir,
+  mountPrefixOf,
+  rstripSlash
+} 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);
+  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 entries;
+  try {
+    entries = await fsReaddir(full);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOTDIR") throw enotdir(path9);
+    if (code === "ENOENT") throw enotdir(path9);
+    throw err;
+  }
+  const base = norm(virtual);
+  const dirPrefix = base === "/" ? "/" : `${base}/`;
+  const sorted = [...entries].sort();
+  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 enoent4,
+  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 enoent4(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, path9) {
+  const full = resolveSafe(accessor.root, path9.mountPath);
+  await rm(full, { recursive: true, force: true });
+  await invalidateAfterUnlink2(path9);
+}
+
+// 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);
+  try {
+    await fsRmdir(full);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+  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 enoent6, recordStream, ResourceName as ResourceName4 } from "@struktoai/mirage-core";
+async function* stream(accessor, path9) {
+  const virtual = path9.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 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.mountPath);
+  try {
+    await fsUnlink(full);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+  await invalidateAfterUnlink4(path9);
+}
+
+// src/commands/builtin/disk/io.ts
+var DISK_IO = {
+  readdir: readdir3,
+  readBytes: read,
+  readStream: stream,
+  stat,
+  isMounted: (a) => a.root !== "",
+  local: true,
+  maxGlobMatches: SCOPE_ERROR,
+  write: writeBytes,
+  exists,
+  mkdir: mkdir4,
+  unlink,
+  rmdir,
+  rmR,
+  rename,
+  copy,
+  create,
+  truncate,
+  append: appendBytes,
+  setAttrs,
+  find,
+  duTotal: du,
+  duAll
+};
+
+// src/commands/builtin/disk/index.ts
+var DISK_COMMANDS = [
+  ...makeFiletypeCommands({
+    resource: ResourceName5.DISK,
+    readBytes: read,
+    statEntry: stat
+  }),
+  ...makeGenericCommands(ResourceName5.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 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}
+  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 entries = await readdir4(current, { withFileTypes: true });
+  for (const e of entries) {
+    const child = path8.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 = ResourceName7.DISK;
+  cachesReads = false;
+  indexTtl = 60;
+  prompt = DISK_PROMPT;
+  root;
+  accessor;
+  opsMap = {
+    read_bytes: read,
+    write: writeBytes,
+    readdir: readdir3,
+    stat,
+    unlink,
+    rmdir,
+    copy,
+    rename,
+    mkdir: mkdir4,
+    read_stream: stream,
+    rm_recursive: rmR,
+    du_total: du,
+    du_all: duAll,
+    create,
+    truncate,
+    exists,
+    find_flat: find,
+    append: appendBytes
+  };
+  constructor(options) {
+    super();
+    this.root = path8.resolve(options.root);
+    this.accessor = new DiskAccessor(this.root);
+  }
+  async open() {
+    await mkdir5(this.root, { recursive: true });
+  }
+  close() {
+    return Promise.resolve();
+  }
+  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 stat(this.accessor, p);
+  }
+  exists(p) {
+    return exists(this.accessor, p);
+  }
+  mkdir(p, options) {
+    return mkdir4(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 du(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 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,
+      modes
+    };
+  }
+  async loadState(state) {
+    await mkdir5(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 });
+      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-W5ZLIQFR.js.map