@struktoai/mirage-browser 0.0.2-alpha.0 → 0.0.2

package/dist/chunk-SJB2KXDM.js

@@ -0,0 +1,2109 @@
+// src/resource/opfs/opfs.ts
+import {
+  ResourceName as ResourceName80,
+  lstripSlash
+} from "@struktoai/mirage-core";
+
+// src/accessor/opfs.ts
+import { Accessor } from "@struktoai/mirage-core";
+var OPFSAccessor = class extends Accessor {
+  provider;
+  constructor(provider) {
+    super();
+    this.provider = provider;
+  }
+  get rootHandle() {
+    return this.provider.requireHandle();
+  }
+};
+
+// src/commands/builtin/opfs/index.ts
+import { makeFiletypeCommands, ResourceName as ResourceName67 } from "@struktoai/mirage-core";
+
+// src/core/opfs/read.ts
+import { record, ResourceName } from "@struktoai/mirage-core";
+import { enoent } from "@struktoai/mirage-core";
+
+// src/core/opfs/utils.ts
+import { norm, parent, gnuBasename } from "@struktoai/mirage-core";
+function splitSegments(virtual) {
+  const parts = [];
+  for (const seg of virtual.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (parts.length === 0) {
+        throw new Error(`path escapes root: ${virtual}`);
+      }
+      parts.pop();
+      continue;
+    }
+    parts.push(seg);
+  }
+  return parts;
+}
+async function resolveDirHandle(root, virtual, options = {}) {
+  const segs = splitSegments(virtual);
+  let handle = root;
+  for (const seg of segs) {
+    handle = await handle.getDirectoryHandle(seg, { create: options.create ?? false });
+  }
+  return handle;
+}
+async function resolveFileHandle(root, virtual, options = {}) {
+  const segs = splitSegments(virtual);
+  const fileName = segs.pop();
+  if (fileName === void 0) {
+    throw new Error(`not a file: ${virtual}`);
+  }
+  let dir = root;
+  for (const seg of segs) {
+    dir = await dir.getDirectoryHandle(seg, { create: options.create ?? false });
+  }
+  return dir.getFileHandle(fileName, { create: options.create ?? false });
+}
+async function resolveParentDirHandle(root, virtual, options = {}) {
+  const segs = splitSegments(virtual);
+  const name = segs.pop();
+  if (name === void 0) {
+    throw new Error(`no parent directory: ${virtual}`);
+  }
+  let dir = root;
+  for (const seg of segs) {
+    dir = await dir.getDirectoryHandle(seg, { create: options.create ?? false });
+  }
+  return [dir, name];
+}
+function isNotFound(err) {
+  if (err instanceof DOMException) {
+    return err.name === "NotFoundError";
+  }
+  return false;
+}
+function toWritableChunk(data) {
+  const copy2 = new Uint8Array(data.byteLength);
+  copy2.set(data);
+  return new Blob([copy2]);
+}
+async function* iterEntries(dir) {
+  const iter = dir.entries();
+  for await (const [name, handle] of iter) {
+    yield [name, handle];
+  }
+}
+
+// src/core/opfs/read.ts
+async function read(accessor, path) {
+  const root = accessor.rootHandle;
+  const start = performance.now();
+  const virtual = path.stripPrefix;
+  let handle;
+  try {
+    handle = await resolveFileHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) throw enoent(path);
+    throw err;
+  }
+  const file = await handle.getFile();
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  record("read", virtual, ResourceName.OPFS, bytes.byteLength, start);
+  return bytes;
+}
+
+// src/core/opfs/stat.ts
+import { FileStat, FileType, guessType } from "@struktoai/mirage-core";
+import { enoent as enoent2 } from "@struktoai/mirage-core";
+async function stat(accessor, p) {
+  const root = accessor.rootHandle;
+  const virtual = p.stripPrefix;
+  const segs = splitSegments(virtual);
+  const last = segs.at(-1);
+  if (last === void 0) {
+    return new FileStat({
+      name: "/",
+      size: null,
+      modified: null,
+      type: FileType.DIRECTORY
+    });
+  }
+  const name = last;
+  let parentDir;
+  let entryName;
+  try {
+    ;
+    [parentDir, entryName] = await resolveParentDirHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) throw enoent2(p);
+    throw err;
+  }
+  try {
+    const fileHandle = await parentDir.getFileHandle(entryName, { create: false });
+    const file = await fileHandle.getFile();
+    const modified = new Date(file.lastModified).toISOString();
+    return new FileStat({
+      name,
+      size: file.size,
+      modified,
+      fingerprint: modified,
+      type: guessType(name)
+    });
+  } catch (err) {
+    if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
+      throw err;
+    }
+  }
+  try {
+    await resolveDirHandle(root, virtual, { create: false });
+    return new FileStat({
+      name,
+      size: null,
+      modified: null,
+      type: FileType.DIRECTORY
+    });
+  } catch (err) {
+    if (isNotFound(err)) throw enoent2(p);
+    throw err;
+  }
+}
+
+// src/commands/builtin/opfs/awk.ts
+import { ResourceName as ResourceName3, awkGeneric, command, specOf } from "@struktoai/mirage-core";
+
+// src/core/opfs/stream.ts
+import { recordStream, ResourceName as ResourceName2 } from "@struktoai/mirage-core";
+import { enoent as enoent3 } from "@struktoai/mirage-core";
+async function* stream(accessor, path) {
+  const root = accessor.rootHandle;
+  const virtual = path.stripPrefix;
+  let handle;
+  try {
+    handle = await resolveFileHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) throw enoent3(path);
+    throw err;
+  }
+  const file = await handle.getFile();
+  const rec = recordStream("read", virtual, ResourceName2.OPFS);
+  const reader = file.stream().getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (rec !== null) rec.bytes += value.byteLength;
+    yield value;
+  }
+}
+
+// src/commands/builtin/opfs/awk.ts
+var OPFS_AWK = command({
+  name: "awk",
+  resource: ResourceName3.OPFS,
+  spec: specOf("awk"),
+  fn: (accessor, paths, texts, opts) => awkGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/base64_cmd.ts
+import { ResourceName as ResourceName4, command as command2, specOf as specOf2, base64Generic } from "@struktoai/mirage-core";
+var OPFS_BASE64 = command2({
+  name: "base64",
+  resource: ResourceName4.OPFS,
+  spec: specOf2("base64"),
+  fn: (accessor, paths, _texts, opts) => base64Generic(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/basename.ts
+import { ResourceName as ResourceName5, command as command3, specOf as specOf3, basenameFn } from "@struktoai/mirage-core";
+var OPFS_BASENAME = command3({
+  name: "basename",
+  resource: ResourceName5.OPFS,
+  spec: specOf3("basename"),
+  fn: basenameFn
+});
+
+// src/commands/builtin/opfs/cat/cat.ts
+import {
+  ResourceName as ResourceName6,
+  catGeneric,
+  catProvisionGeneric,
+  command as command4,
+  concatAggregate,
+  specOf as specOf4
+} from "@struktoai/mirage-core";
+var OPFS_CAT = command4({
+  name: "cat",
+  resource: ResourceName6.OPFS,
+  spec: specOf4("cat"),
+  fn: (accessor, paths, texts, opts) => catGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => stream(accessor, p)
+  ),
+  provision: (accessor, paths, _texts, _opts) => catProvisionGeneric(paths, (p) => stat(accessor, p)),
+  aggregate: concatAggregate
+});
+
+// src/commands/builtin/opfs/cmp.ts
+import { ResourceName as ResourceName7, command as command5, specOf as specOf5, cmpGeneric } from "@struktoai/mirage-core";
+var OPFS_CMP = command5({
+  name: "cmp",
+  resource: ResourceName7.OPFS,
+  spec: specOf5("cmp"),
+  fn: (accessor, paths, _texts, opts) => cmpGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/column.ts
+import { ResourceName as ResourceName8, command as command6, specOf as specOf6, columnGeneric } from "@struktoai/mirage-core";
+var OPFS_COLUMN = command6({
+  name: "column",
+  resource: ResourceName8.OPFS,
+  spec: specOf6("column"),
+  fn: (accessor, paths, _texts, opts) => columnGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/comm.ts
+import { ResourceName as ResourceName9, command as command7, specOf as specOf7, commGeneric } from "@struktoai/mirage-core";
+var OPFS_COMM = command7({
+  name: "comm",
+  resource: ResourceName9.OPFS,
+  spec: specOf7("comm"),
+  fn: (accessor, paths, _texts, opts) => commGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/cp.ts
+import {
+  IOResult,
+  ResourceName as ResourceName10,
+  command as command8,
+  cpGeneric,
+  specOf as specOf8
+} from "@struktoai/mirage-core";
+
+// src/core/opfs/copy.ts
+async function copy(accessor, src, dst) {
+  const root = accessor.rootHandle;
+  let srcHandle;
+  try {
+    srcHandle = await resolveFileHandle(root, src.stripPrefix, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) throw new Error(`file not found: ${src.stripPrefix}`);
+    throw err;
+  }
+  const file = await srcHandle.getFile();
+  const data = new Uint8Array(await file.arrayBuffer());
+  const dstHandle = await resolveFileHandle(root, dst.stripPrefix, { create: true });
+  const writable = await dstHandle.createWritable();
+  await writable.write(toWritableChunk(data));
+  await writable.close();
+}
+
+// src/core/opfs/find.ts
+import { buildTree, keep } from "@struktoai/mirage-core";
+async function walk(ctx, dir, current, depth) {
+  const opts = ctx.options;
+  if (opts.maxDepth !== null && opts.maxDepth !== void 0 && depth > opts.maxDepth) return;
+  let iter;
+  try {
+    iter = iterEntries(dir);
+  } catch {
+    return;
+  }
+  for await (const [entryName, handle] of iter) {
+    const kind = handle.kind === "directory" ? "d" : "f";
+    const entryPath = current === "/" ? `/${entryName}` : `${current}/${entryName}`;
+    const entryDepth = depth + 1;
+    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 {
+        if (kind === "f") {
+          isEmpty = (await handle.getFile()).size === 0;
+        } else {
+          isEmpty = true;
+          for await (const _child of iterEntries(handle)) {
+            void _child;
+            isEmpty = false;
+            break;
+          }
+        }
+      } 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 || opts.mtimeMin !== null || opts.mtimeMax !== null)) {
+      try {
+        const fh = await dir.getFileHandle(entryName, { create: false });
+        const file = await fh.getFile();
+        if (opts.minSize !== null && opts.minSize !== void 0 && file.size < opts.minSize)
+          accept = false;
+        if (opts.maxSize !== null && opts.maxSize !== void 0 && file.size > opts.maxSize)
+          accept = false;
+        if (accept && (opts.mtimeMin !== void 0 || opts.mtimeMax !== void 0)) {
+          const mtime = file.lastModified / 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") {
+      try {
+        const child = await dir.getDirectoryHandle(entryName, { create: false });
+        await walk(ctx, child, entryPath, depth + 1);
+      } catch {
+      }
+    }
+  }
+}
+async function find(accessor, p, options = {}) {
+  const root = accessor.rootHandle;
+  const virtual = norm(p.stripPrefix);
+  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
+  });
+  let dir;
+  try {
+    dir = await resolveDirHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) return results;
+    throw err;
+  }
+  if (virtual !== "/" && (options.maxDepth == null || options.maxDepth >= 0)) {
+    let rootEmpty = null;
+    if (options.empty === true) {
+      rootEmpty = true;
+      for await (const _child of iterEntries(dir)) {
+        void _child;
+        rootEmpty = false;
+        break;
+      }
+    }
+    if (keep(
+      {
+        key: virtual,
+        name: virtual.slice(virtual.lastIndexOf("/") + 1),
+        kind: "d",
+        depth: 0,
+        isEmpty: rootEmpty
+      },
+      tree,
+      options.minDepth
+    )) {
+      results.push(virtual);
+    }
+  }
+  await walk({ options, tree, results }, dir, virtual, 0);
+  results.sort();
+  return results;
+}
+
+// src/commands/builtin/opfs/cp.ts
+function cpCommand(accessor, paths, _texts, opts) {
+  if (paths.length < 2) {
+    return Promise.resolve([
+      null,
+      new IOResult({ exitCode: 1, stderr: new TextEncoder().encode("cp: missing operand\n") })
+    ]);
+  }
+  const recursive = opts.flags.r === true || opts.flags.R === true || opts.flags.a === true;
+  return cpGeneric(
+    paths,
+    (src, target) => copy(accessor, src, target),
+    (src, options) => find(accessor, src, options),
+    (p) => stat(accessor, p),
+    recursive,
+    opts.flags.n === true,
+    opts.flags.v === true,
+    opts.index ?? void 0
+  );
+}
+var OPFS_CP = command8({
+  name: "cp",
+  resource: ResourceName10.OPFS,
+  spec: specOf8("cp"),
+  fn: cpCommand,
+  write: true
+});
+
+// src/commands/builtin/opfs/csplit.ts
+import { ResourceName as ResourceName12, command as command9, specOf as specOf9, csplitGeneric } from "@struktoai/mirage-core";
+
+// src/core/opfs/write.ts
+import { record as record2, ResourceName as ResourceName11 } from "@struktoai/mirage-core";
+async function writeBytes(accessor, p, data) {
+  const root = accessor.rootHandle;
+  const start = performance.now();
+  const virtual = p.stripPrefix;
+  const handle = await resolveFileHandle(root, virtual, { create: true });
+  const writable = await handle.createWritable();
+  await writable.write(toWritableChunk(data));
+  await writable.close();
+  record2("write", virtual, ResourceName11.OPFS, data.byteLength, start);
+}
+
+// src/commands/builtin/opfs/csplit.ts
+var OPFS_CSPLIT = command9({
+  name: "csplit",
+  resource: ResourceName12.OPFS,
+  spec: specOf9("csplit"),
+  fn: (accessor, paths, texts, opts) => csplitGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/cut/cut.ts
+import { ResourceName as ResourceName13, command as command10, cutGeneric, specOf as specOf10 } from "@struktoai/mirage-core";
+var OPFS_CUT = command10({
+  name: "cut",
+  resource: ResourceName13.OPFS,
+  spec: specOf10("cut"),
+  fn: (accessor, paths, _texts, opts) => cutGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/diff.ts
+import { ResourceName as ResourceName14, command as command11, diffGeneric, specOf as specOf11 } from "@struktoai/mirage-core";
+var OPFS_DIFF = command11({
+  name: "diff",
+  resource: ResourceName14.OPFS,
+  spec: specOf11("diff"),
+  fn: (accessor, paths, _texts, opts) => diffGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/dirname.ts
+import { ResourceName as ResourceName15, command as command12, specOf as specOf12, dirnameFn } from "@struktoai/mirage-core";
+var OPFS_DIRNAME = command12({
+  name: "dirname",
+  resource: ResourceName15.OPFS,
+  spec: specOf12("dirname"),
+  fn: dirnameFn
+});
+
+// src/commands/builtin/opfs/du.ts
+import { ResourceName as ResourceName16, command as command13, duGeneric, specOf as specOf13 } from "@struktoai/mirage-core";
+
+// src/core/opfs/du.ts
+async function walkSizes(dir) {
+  let total = 0;
+  for await (const [name, handle] of iterEntries(dir)) {
+    if (handle.kind === "file") {
+      try {
+        const fh = await dir.getFileHandle(name, { create: false });
+        const file = await fh.getFile();
+        total += file.size;
+      } catch {
+      }
+    } else {
+      try {
+        const child = await dir.getDirectoryHandle(name, { create: false });
+        total += await walkSizes(child);
+      } catch {
+      }
+    }
+  }
+  return total;
+}
+async function walkAll(dir, currentPath, entries) {
+  let total = 0;
+  for await (const [name, handle] of iterEntries(dir)) {
+    const childPath = currentPath === "/" ? `/${name}` : `${currentPath}/${name}`;
+    if (handle.kind === "file") {
+      try {
+        const fh = await dir.getFileHandle(name, { create: false });
+        const file = await fh.getFile();
+        entries.push([childPath, file.size]);
+        total += file.size;
+      } catch {
+      }
+    } else {
+      try {
+        const child = await dir.getDirectoryHandle(name, { create: false });
+        total += await walkAll(child, childPath, entries);
+      } catch {
+      }
+    }
+  }
+  return total;
+}
+async function sizeOfPath(root, virtual) {
+  try {
+    const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
+    try {
+      const fh = await parentDir.getFileHandle(name, { create: false });
+      const file = await fh.getFile();
+      return file.size;
+    } catch (err) {
+      if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
+        throw err;
+      }
+    }
+    const dir = await parentDir.getDirectoryHandle(name, { create: false });
+    return await walkSizes(dir);
+  } catch (err) {
+    if (isNotFound(err)) return 0;
+    if (err instanceof Error && err.message.startsWith("no parent directory")) {
+      try {
+        const rootDir = await resolveDirHandle(root, virtual, { create: false });
+        return await walkSizes(rootDir);
+      } catch {
+        return 0;
+      }
+    }
+    throw err;
+  }
+}
+async function du(accessor, p) {
+  return sizeOfPath(accessor.rootHandle, p.stripPrefix);
+}
+async function duAll(accessor, p) {
+  const root = accessor.rootHandle;
+  const virtual = norm(p.stripPrefix);
+  const entries = [];
+  try {
+    const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
+    try {
+      const fh = await parentDir.getFileHandle(name, { create: false });
+      const file = await fh.getFile();
+      entries.push([virtual, file.size]);
+      return [entries, file.size];
+    } catch (err) {
+      if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
+        throw err;
+      }
+    }
+    const dir = await parentDir.getDirectoryHandle(name, { create: false });
+    const total = await walkAll(dir, virtual, entries);
+    entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    return [entries, total];
+  } catch (err) {
+    if (isNotFound(err)) return [entries, 0];
+    if (err instanceof Error && err.message.startsWith("no parent directory")) {
+      try {
+        const rootDir = await resolveDirHandle(root, virtual, { create: false });
+        const total = await walkAll(rootDir, virtual, entries);
+        entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+        return [entries, total];
+      } catch {
+        return [entries, 0];
+      }
+    }
+    throw err;
+  }
+}
+
+// src/commands/builtin/opfs/du.ts
+var OPFS_DU = command13({
+  name: "du",
+  resource: ResourceName16.OPFS,
+  spec: specOf13("du"),
+  fn: (accessor, paths, _texts, opts) => duGeneric(
+    paths,
+    opts,
+    (p) => du(accessor, p),
+    (p) => duAll(accessor, p)
+  )
+});
+
+// src/commands/builtin/opfs/expand.ts
+import { ResourceName as ResourceName17, command as command14, specOf as specOf14, expandGeneric } from "@struktoai/mirage-core";
+var OPFS_EXPAND = command14({
+  name: "expand",
+  resource: ResourceName17.OPFS,
+  spec: specOf14("expand"),
+  fn: (accessor, paths, _texts, opts) => expandGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/file/file.ts
+import { ResourceName as ResourceName18, command as command15, fileGeneric, specOf as specOf15 } from "@struktoai/mirage-core";
+var OPFS_FILE = command15({
+  name: "file",
+  resource: ResourceName18.OPFS,
+  spec: specOf15("file"),
+  fn: (accessor, paths, _texts, opts) => fileGeneric(
+    paths,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => read(accessor, p)
+  )
+});
+
+// src/commands/builtin/opfs/find.ts
+import { ResourceName as ResourceName19, command as command16, findGeneric, specOf as specOf16 } from "@struktoai/mirage-core";
+var OPFS_FIND = command16({
+  name: "find",
+  resource: ResourceName19.OPFS,
+  spec: specOf16("find"),
+  fn: (accessor, paths, texts, opts) => findGeneric(paths, texts, opts, (root, options) => find(accessor, root, options))
+});
+
+// src/commands/builtin/opfs/fmt.ts
+import {
+  ResourceName as ResourceName20,
+  command as command17,
+  fmtGeneric,
+  specOf as specOf17
+} from "@struktoai/mirage-core";
+async function fmtCommand(accessor, paths, _texts, opts) {
+  return fmtGeneric(paths, opts, (p) => stream(accessor, p));
+}
+var OPFS_FMT = command17({
+  name: "fmt",
+  resource: ResourceName20.OPFS,
+  spec: specOf17("fmt"),
+  fn: fmtCommand
+});
+
+// src/commands/builtin/opfs/fold.ts
+import { ResourceName as ResourceName21, command as command18, specOf as specOf18, foldGeneric } from "@struktoai/mirage-core";
+var OPFS_FOLD = command18({
+  name: "fold",
+  resource: ResourceName21.OPFS,
+  spec: specOf18("fold"),
+  fn: (accessor, paths, _texts, opts) => foldGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/grep/grep.ts
+import { ResourceName as ResourceName22, command as command19, grepGeneric, prefixAggregate, specOf as specOf19 } from "@struktoai/mirage-core";
+
+// src/core/opfs/readdir.ts
+import { enotdir } from "@struktoai/mirage-core";
+async function readdir(accessor, path) {
+  const root = accessor.rootHandle;
+  const virtual = path.pattern !== null ? path.directory : path.stripPrefix;
+  let dir;
+  try {
+    dir = await resolveDirHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) throw enotdir(path);
+    if (err instanceof DOMException && err.name === "TypeMismatchError") {
+      throw enotdir(path);
+    }
+    throw err;
+  }
+  const names = [];
+  for await (const [name] of iterEntries(dir)) {
+    names.push(name);
+  }
+  const base = norm(virtual);
+  const dirPrefix = base === "/" ? "/" : `${base}/`;
+  const mountPrefix = path.prefix;
+  return names.map((n) => `${mountPrefix}${dirPrefix}${n}`).sort();
+}
+
+// src/commands/builtin/opfs/grep/grep.ts
+var OPFS_GREP = command19({
+  name: "grep",
+  resource: ResourceName22.OPFS,
+  spec: specOf19("grep"),
+  fn: (accessor, paths, texts, opts) => grepGeneric(
+    "grep",
+    paths,
+    texts,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => readdir(accessor, p),
+    (p) => stream(accessor, p)
+  ),
+  aggregate: prefixAggregate
+});
+
+// src/commands/builtin/opfs/gunzip.ts
+import { ResourceName as ResourceName23, command as command20, specOf as specOf20, gunzipGeneric } from "@struktoai/mirage-core";
+
+// src/core/opfs/unlink.ts
+async function unlink(accessor, path) {
+  const root = accessor.rootHandle;
+  const virtual = path.stripPrefix;
+  let parentDir;
+  let name;
+  try {
+    ;
+    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) return;
+    if (err instanceof Error && err.message.startsWith("no parent directory")) return;
+    throw err;
+  }
+  try {
+    await parentDir.removeEntry(name);
+  } catch (err) {
+    if (isNotFound(err)) return;
+    throw err;
+  }
+}
+
+// src/commands/builtin/opfs/gunzip.ts
+var OPFS_GUNZIP = command20({
+  name: "gunzip",
+  resource: ResourceName23.OPFS,
+  spec: specOf20("gunzip"),
+  fn: (accessor, paths, _texts, opts) => gunzipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d),
+    (p) => unlink(accessor, p)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/gzip.ts
+import { ResourceName as ResourceName24, command as command21, specOf as specOf21, gzipGeneric } from "@struktoai/mirage-core";
+var OPFS_GZIP = command21({
+  name: "gzip",
+  resource: ResourceName24.OPFS,
+  spec: specOf21("gzip"),
+  fn: (accessor, paths, _texts, opts) => gzipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d),
+    (p) => unlink(accessor, p)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/head/head.ts
+import {
+  ResourceName as ResourceName25,
+  command as command22,
+  headGeneric,
+  headProvisionGeneric,
+  headerAggregate,
+  specOf as specOf22
+} from "@struktoai/mirage-core";
+var OPFS_HEAD = command22({
+  name: "head",
+  resource: ResourceName25.OPFS,
+  spec: specOf22("head"),
+  fn: (accessor, paths, texts, opts) => headGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => stream(accessor, p)
+  ),
+  provision: (accessor, paths, texts, opts) => headProvisionGeneric(paths, texts, opts, (p) => stat(accessor, p)),
+  aggregate: headerAggregate
+});
+
+// src/commands/builtin/opfs/iconv.ts
+import { ResourceName as ResourceName26, command as command23, specOf as specOf23, iconvGeneric } from "@struktoai/mirage-core";
+var OPFS_ICONV = command23({
+  name: "iconv",
+  resource: ResourceName26.OPFS,
+  spec: specOf23("iconv"),
+  fn: (accessor, paths, _texts, opts) => iconvGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/join.ts
+import { ResourceName as ResourceName27, command as command24, specOf as specOf24, joinGeneric } from "@struktoai/mirage-core";
+var OPFS_JOIN = command24({
+  name: "join",
+  resource: ResourceName27.OPFS,
+  spec: specOf24("join"),
+  fn: (accessor, paths, _texts, opts) => joinGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/jq.ts
+import {
+  ResourceName as ResourceName28,
+  command as command25,
+  jqGeneric,
+  jqProvisionGeneric,
+  specOf as specOf25
+} from "@struktoai/mirage-core";
+var OPFS_JQ = command25({
+  name: "jq",
+  resource: ResourceName28.OPFS,
+  spec: specOf25("jq"),
+  fn: (accessor, paths, texts, opts) => jqGeneric(paths, texts, opts, (p) => stream(accessor, p)),
+  provision: (accessor, paths, texts, _opts) => jqProvisionGeneric(paths, texts, (p) => stat(accessor, p))
+});
+
+// src/commands/builtin/opfs/ln.ts
+import {
+  IOResult as IOResult2,
+  ResourceName as ResourceName29,
+  command as command26,
+  materialize,
+  specOf as specOf26
+} from "@struktoai/mirage-core";
+
+// src/core/opfs/exists.ts
+async function exists(accessor, path) {
+  const root = accessor.rootHandle;
+  const virtual = path.stripPrefix;
+  if (virtual === "/" || virtual === "") return true;
+  try {
+    const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
+    try {
+      await parentDir.getFileHandle(name, { create: false });
+      return true;
+    } catch (err) {
+      if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
+        throw err;
+      }
+    }
+    try {
+      await parentDir.getDirectoryHandle(name, { create: false });
+      return true;
+    } catch (err) {
+      if (isNotFound(err) || err instanceof DOMException && err.name === "TypeMismatchError") {
+        return false;
+      }
+      throw err;
+    }
+  } catch (err) {
+    if (isNotFound(err)) return false;
+    if (err instanceof Error && err.message.startsWith("path escapes root")) return false;
+    if (err instanceof Error && err.message.startsWith("no parent directory")) {
+      try {
+        await resolveDirHandle(root, virtual, { create: false });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    throw err;
+  }
+}
+
+// src/commands/builtin/opfs/ln.ts
+var ENC = new TextEncoder();
+async function lnCommand(accessor, paths, texts, opts) {
+  if (paths.length < 2) {
+    return [
+      null,
+      new IOResult2({ exitCode: 1, stderr: ENC.encode("ln: usage: ln [-s] [-f] source dest\n") })
+    ];
+  }
+  const source = paths[0];
+  const dest = paths[1];
+  if (source === void 0 || dest === void 0) return [null, new IOResult2()];
+  if (opts.flags.n === true && await exists(accessor, dest)) {
+    return [null, new IOResult2()];
+  }
+  const data = await materialize(stream(accessor, source));
+  await writeBytes(accessor, dest, data);
+  const out = opts.flags.v === true ? ENC.encode(`'${source.original}' -> '${dest.original}'
+`) : null;
+  return [out, new IOResult2({ writes: { [dest.stripPrefix]: data } })];
+}
+var OPFS_LN = command26({
+  name: "ln",
+  resource: ResourceName29.OPFS,
+  spec: specOf26("ln"),
+  fn: lnCommand,
+  write: true
+});
+
+// src/commands/builtin/opfs/look.ts
+import { ResourceName as ResourceName30, command as command27, specOf as specOf27, lookGeneric } from "@struktoai/mirage-core";
+var OPFS_LOOK = command27({
+  name: "look",
+  resource: ResourceName30.OPFS,
+  spec: specOf27("look"),
+  fn: (accessor, paths, texts, opts) => lookGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/ls/ls.ts
+import { ResourceName as ResourceName31, command as command28, lsGeneric, specOf as specOf28 } from "@struktoai/mirage-core";
+var OPFS_LS = command28({
+  name: "ls",
+  resource: ResourceName31.OPFS,
+  spec: specOf28("ls"),
+  fn: (accessor, paths, _texts, opts) => lsGeneric(
+    paths,
+    opts,
+    (p) => readdir(accessor, p),
+    (p) => stat(accessor, p)
+  )
+});
+
+// src/commands/builtin/opfs/md5.ts
+import { ResourceName as ResourceName32, command as command29, specOf as specOf29, md5Generic } from "@struktoai/mirage-core";
+var OPFS_MD5 = command29({
+  name: "md5",
+  resource: ResourceName32.OPFS,
+  spec: specOf29("md5"),
+  fn: (accessor, paths, _texts, opts) => md5Generic(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/mkdir.ts
+import {
+  IOResult as IOResult3,
+  ResourceName as ResourceName33,
+  command as command30,
+  specOf as specOf30
+} from "@struktoai/mirage-core";
+
+// src/core/opfs/mkdir.ts
+async function mkdir(accessor, path, parents = false) {
+  const root = accessor.rootHandle;
+  const virtual = path.stripPrefix;
+  const segs = splitSegments(virtual);
+  if (segs.length === 0) return;
+  if (parents) {
+    await resolveDirHandle(root, virtual, { create: true });
+    return;
+  }
+  let parentDir;
+  let name;
+  try {
+    ;
+    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) {
+      throw new Error(`parent directory does not exist: ${virtual}`);
+    }
+    throw err;
+  }
+  try {
+    await parentDir.getDirectoryHandle(name, { create: false });
+    return;
+  } catch (err) {
+    if (!isNotFound(err)) {
+      if (err instanceof DOMException && err.name === "TypeMismatchError") {
+        throw new Error(`path exists and is not a directory: ${virtual}`);
+      }
+      throw err;
+    }
+  }
+  await parentDir.getDirectoryHandle(name, { create: true });
+}
+
+// src/commands/builtin/opfs/mkdir.ts
+async function mkdirCommand(accessor, paths, texts, opts) {
+  const parents = opts.flags.p === true;
+  if (paths.length === 0) {
+    return [
+      null,
+      new IOResult3({
+        exitCode: 1,
+        stderr: new TextEncoder().encode("mkdir: missing operand\n")
+      })
+    ];
+  }
+  for (const p of paths) {
+    await mkdir(accessor, p, parents);
+  }
+  return [null, new IOResult3()];
+}
+var OPFS_MKDIR = command30({
+  name: "mkdir",
+  resource: ResourceName33.OPFS,
+  spec: specOf30("mkdir"),
+  fn: mkdirCommand,
+  write: true
+});
+
+// src/commands/builtin/opfs/mktemp.ts
+import { ResourceName as ResourceName34, command as command31, mktempGeneric, specOf as specOf31 } from "@struktoai/mirage-core";
+var OPFS_MKTEMP = command31({
+  name: "mktemp",
+  resource: ResourceName34.OPFS,
+  spec: specOf31("mktemp"),
+  fn: (accessor, _paths, texts, opts) => mktempGeneric(
+    texts,
+    opts,
+    (p, parents) => mkdir(accessor, p, parents),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/mv.ts
+import {
+  IOResult as IOResult4,
+  ResourceName as ResourceName35,
+  command as command32,
+  mvGeneric,
+  specOf as specOf32
+} from "@struktoai/mirage-core";
+
+// src/core/opfs/rename.ts
+async function copyDirRecursive(root, srcPath, dstPath) {
+  const srcDir = await resolveDirHandle(root, srcPath, { create: false });
+  const dstDir = await resolveDirHandle(root, dstPath, { create: true });
+  for await (const [name, handle] of iterEntries(srcDir)) {
+    if (handle.kind === "file") {
+      const srcFile = await srcDir.getFileHandle(name, { create: false });
+      const file = await srcFile.getFile();
+      const data = new Uint8Array(await file.arrayBuffer());
+      const dstFile = await dstDir.getFileHandle(name, { create: true });
+      const writable = await dstFile.createWritable();
+      await writable.write(toWritableChunk(data));
+      await writable.close();
+    } else {
+      await copyDirRecursive(root, `${srcPath}/${name}`, `${dstPath}/${name}`);
+    }
+  }
+}
+async function rename(accessor, src, dst) {
+  const root = accessor.rootHandle;
+  const srcPath = src.stripPrefix;
+  const dstPath = dst.stripPrefix;
+  let srcParent;
+  let srcName;
+  try {
+    ;
+    [srcParent, srcName] = await resolveParentDirHandle(root, srcPath, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) throw new Error(`file or directory not found: ${srcPath}`);
+    throw err;
+  }
+  let isFile = false;
+  try {
+    await srcParent.getFileHandle(srcName, { create: false });
+    isFile = true;
+  } catch (err) {
+    if (!isNotFound(err) && !(err instanceof DOMException && err.name === "TypeMismatchError")) {
+      throw err;
+    }
+  }
+  if (!isFile) {
+    try {
+      await srcParent.getDirectoryHandle(srcName, { create: false });
+    } catch (err) {
+      if (isNotFound(err)) throw new Error(`file or directory not found: ${srcPath}`);
+      throw err;
+    }
+  }
+  if (isFile) {
+    const srcFile = await resolveFileHandle(root, srcPath, { create: false });
+    const file = await srcFile.getFile();
+    const data = new Uint8Array(await file.arrayBuffer());
+    const dstFile = await resolveFileHandle(root, dstPath, { create: true });
+    const writable = await dstFile.createWritable();
+    await writable.write(toWritableChunk(data));
+    await writable.close();
+    await srcParent.removeEntry(srcName);
+    return;
+  }
+  await copyDirRecursive(root, srcPath, dstPath);
+  await srcParent.removeEntry(srcName, { recursive: true });
+}
+
+// src/commands/builtin/opfs/mv.ts
+function mvCommand(accessor, paths, _texts, opts) {
+  if (paths.length < 2) {
+    return Promise.resolve([
+      null,
+      new IOResult4({ exitCode: 1, stderr: new TextEncoder().encode("mv: missing operand\n") })
+    ]);
+  }
+  return mvGeneric(
+    paths,
+    (src, target) => rename(accessor, src, target),
+    (p) => stat(accessor, p),
+    opts.flags.n === true,
+    opts.flags.v === true,
+    opts.index ?? void 0
+  );
+}
+var OPFS_MV = command32({
+  name: "mv",
+  resource: ResourceName35.OPFS,
+  spec: specOf32("mv"),
+  fn: mvCommand,
+  write: true
+});
+
+// src/commands/builtin/opfs/nl.ts
+import { ResourceName as ResourceName36, command as command33, specOf as specOf33, nlGeneric } from "@struktoai/mirage-core";
+var OPFS_NL = command33({
+  name: "nl",
+  resource: ResourceName36.OPFS,
+  spec: specOf33("nl"),
+  fn: (accessor, paths, _texts, opts) => nlGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/paste.ts
+import { ResourceName as ResourceName37, command as command34, specOf as specOf34, pasteGeneric } from "@struktoai/mirage-core";
+var OPFS_PASTE = command34({
+  name: "paste",
+  resource: ResourceName37.OPFS,
+  spec: specOf34("paste"),
+  fn: (accessor, paths, _texts, opts) => pasteGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/patch.ts
+import { ResourceName as ResourceName38, command as command35, specOf as specOf35, patchGeneric } from "@struktoai/mirage-core";
+var OPFS_PATCH = command35({
+  name: "patch",
+  resource: ResourceName38.OPFS,
+  spec: specOf35("patch"),
+  fn: (accessor, paths, _texts, opts) => patchGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/readlink.ts
+import {
+  ResourceName as ResourceName39,
+  command as command36,
+  readlinkGeneric,
+  specOf as specOf36
+} from "@struktoai/mirage-core";
+var OPFS_READLINK = command36({
+  name: "readlink",
+  resource: ResourceName39.OPFS,
+  spec: specOf36("readlink"),
+  fn: (_accessor, paths, texts, opts) => readlinkGeneric(paths, texts, opts)
+});
+
+// src/commands/builtin/opfs/realpath.ts
+import { ResourceName as ResourceName40, command as command37, realpathGeneric, specOf as specOf37 } from "@struktoai/mirage-core";
+var OPFS_REALPATH = command37({
+  name: "realpath",
+  resource: ResourceName40.OPFS,
+  spec: specOf37("realpath"),
+  fn: (accessor, paths, texts, opts) => realpathGeneric(paths, texts, opts, (p) => stat(accessor, p))
+});
+
+// src/commands/builtin/opfs/rev.ts
+import { ResourceName as ResourceName41, command as command38, specOf as specOf38, revGeneric } from "@struktoai/mirage-core";
+var OPFS_REV = command38({
+  name: "rev",
+  resource: ResourceName41.OPFS,
+  spec: specOf38("rev"),
+  fn: (accessor, paths, _texts, opts) => revGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/rg.ts
+import { ResourceName as ResourceName42, command as command39, rgGeneric, specOf as specOf39 } from "@struktoai/mirage-core";
+var OPFS_RG = command39({
+  name: "rg",
+  resource: ResourceName42.OPFS,
+  spec: specOf39("rg"),
+  fn: (accessor, paths, texts, opts) => rgGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => readdir(accessor, p),
+    (p) => stream(accessor, p)
+  )
+});
+
+// src/commands/builtin/opfs/rm.ts
+import {
+  FileType as FileType2,
+  IOResult as IOResult5,
+  ResourceName as ResourceName43,
+  command as command40,
+  specOf as specOf40
+} from "@struktoai/mirage-core";
+
+// src/core/opfs/rmdir.ts
+async function rmdir(accessor, path) {
+  const root = accessor.rootHandle;
+  const virtual = path.stripPrefix;
+  let parentDir;
+  let name;
+  try {
+    ;
+    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) return;
+    if (err instanceof Error && err.message.startsWith("no parent directory")) return;
+    throw err;
+  }
+  try {
+    await parentDir.removeEntry(name, { recursive: false });
+  } catch (err) {
+    if (isNotFound(err)) return;
+    throw err;
+  }
+}
+
+// src/core/opfs/rm.ts
+async function rmR(accessor, path) {
+  const root = accessor.rootHandle;
+  const virtual = path.stripPrefix;
+  let parentDir;
+  let name;
+  try {
+    ;
+    [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
+  } catch (err) {
+    if (isNotFound(err)) return;
+    if (err instanceof Error && err.message.startsWith("no parent directory")) return;
+    throw err;
+  }
+  try {
+    await parentDir.removeEntry(name, { recursive: true });
+  } catch (err) {
+    if (isNotFound(err)) return;
+    throw err;
+  }
+}
+
+// src/commands/builtin/opfs/rm.ts
+async function rmCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0) {
+    return [
+      null,
+      new IOResult5({
+        exitCode: 1,
+        stderr: new TextEncoder().encode("rm: missing operand\n")
+      })
+    ];
+  }
+  const recursive = opts.flags.r === true || opts.flags.R === true;
+  for (const p of paths) {
+    let isDir = false;
+    try {
+      const st = await stat(accessor, p);
+      isDir = st.type === FileType2.DIRECTORY;
+    } catch {
+      isDir = false;
+    }
+    if (isDir) {
+      if (recursive) {
+        await rmR(accessor, p);
+      } else {
+        await rmdir(accessor, p);
+      }
+    } else {
+      await unlink(accessor, p);
+    }
+  }
+  return [null, new IOResult5()];
+}
+var OPFS_RM = command40({
+  name: "rm",
+  resource: ResourceName43.OPFS,
+  spec: specOf40("rm"),
+  fn: rmCommand,
+  write: true
+});
+
+// src/commands/builtin/opfs/sed.ts
+import { ResourceName as ResourceName44, command as command41, specOf as specOf41, sedGeneric } from "@struktoai/mirage-core";
+var OPFS_SED = command41({
+  name: "sed",
+  resource: ResourceName44.OPFS,
+  spec: specOf41("sed"),
+  fn: (accessor, paths, texts, opts) => sedGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  )
+});
+
+// src/commands/builtin/opfs/sha256sum.ts
+import { ResourceName as ResourceName45, command as command42, sha256sumGeneric, specOf as specOf42 } from "@struktoai/mirage-core";
+var OPFS_SHA256SUM = command42({
+  name: "sha256sum",
+  resource: ResourceName45.OPFS,
+  spec: specOf42("sha256sum"),
+  fn: (accessor, paths, _texts, opts) => sha256sumGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/shuf.ts
+import { ResourceName as ResourceName46, command as command43, specOf as specOf43, shufGeneric } from "@struktoai/mirage-core";
+var OPFS_SHUF = command43({
+  name: "shuf",
+  resource: ResourceName46.OPFS,
+  spec: specOf43("shuf"),
+  fn: (accessor, paths, texts, opts) => shufGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/sort.ts
+import { ResourceName as ResourceName47, command as command44, specOf as specOf44, sortGeneric } from "@struktoai/mirage-core";
+var OPFS_SORT = command44({
+  name: "sort",
+  resource: ResourceName47.OPFS,
+  spec: specOf44("sort"),
+  fn: (accessor, paths, _texts, opts) => sortGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/split.ts
+import { ResourceName as ResourceName48, command as command45, specOf as specOf45, splitGeneric } from "@struktoai/mirage-core";
+var OPFS_SPLIT = command45({
+  name: "split",
+  resource: ResourceName48.OPFS,
+  spec: specOf45("split"),
+  fn: (accessor, paths, _texts, opts) => splitGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/stat/stat.ts
+import {
+  ResourceName as ResourceName49,
+  command as command46,
+  specOf as specOf46,
+  statGeneric,
+  statProvisionGeneric
+} from "@struktoai/mirage-core";
+var OPFS_STAT = command46({
+  name: "stat",
+  resource: ResourceName49.OPFS,
+  spec: specOf46("stat"),
+  fn: (accessor, paths, _texts, opts) => statGeneric(paths, opts, (p) => stat(accessor, p)),
+  provision: statProvisionGeneric
+});
+
+// src/commands/builtin/opfs/strings.ts
+import { ResourceName as ResourceName50, command as command47, specOf as specOf47, stringsGeneric } from "@struktoai/mirage-core";
+var OPFS_STRINGS = command47({
+  name: "strings",
+  resource: ResourceName50.OPFS,
+  spec: specOf47("strings"),
+  fn: (accessor, paths, _texts, opts) => stringsGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/tac.ts
+import { ResourceName as ResourceName51, command as command48, specOf as specOf48, tacGeneric } from "@struktoai/mirage-core";
+var OPFS_TAC = command48({
+  name: "tac",
+  resource: ResourceName51.OPFS,
+  spec: specOf48("tac"),
+  fn: (accessor, paths, _texts, opts) => tacGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/tail/tail.ts
+import { ResourceName as ResourceName52, command as command49, headerAggregate as headerAggregate2, specOf as specOf49, tailGeneric } from "@struktoai/mirage-core";
+var OPFS_TAIL = command49({
+  name: "tail",
+  resource: ResourceName52.OPFS,
+  spec: specOf49("tail"),
+  fn: (accessor, paths, texts, opts) => tailGeneric(paths, texts, opts, (p) => stream(accessor, p)),
+  aggregate: headerAggregate2
+});
+
+// src/commands/builtin/opfs/tar.ts
+import { ResourceName as ResourceName53, command as command50, specOf as specOf50, tarGeneric } from "@struktoai/mirage-core";
+var OPFS_TAR = command50({
+  name: "tar",
+  resource: ResourceName53.OPFS,
+  spec: specOf50("tar"),
+  fn: (accessor, paths, _texts, opts) => tarGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, data) => writeBytes(accessor, p, data),
+    (p) => mkdir(accessor, p)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/tee.ts
+import { ResourceName as ResourceName54, command as command51, specOf as specOf51, teeGeneric } from "@struktoai/mirage-core";
+var OPFS_TEE = command51({
+  name: "tee",
+  resource: ResourceName54.OPFS,
+  spec: specOf51("tee"),
+  fn: (accessor, paths, texts, opts) => teeGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/touch.ts
+import {
+  IOResult as IOResult6,
+  ResourceName as ResourceName55,
+  command as command52,
+  specOf as specOf52
+} from "@struktoai/mirage-core";
+var ENC2 = new TextEncoder();
+async function touchCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult6({ exitCode: 1, stderr: ENC2.encode("touch: missing operand\n") })];
+  }
+  const createOnly = opts.flags.c === true;
+  for (const p of paths) {
+    if (createOnly) continue;
+    if (!await exists(accessor, p)) {
+      await writeBytes(accessor, p, new Uint8Array(0));
+    }
+  }
+  return [null, new IOResult6()];
+}
+var OPFS_TOUCH = command52({
+  name: "touch",
+  resource: ResourceName55.OPFS,
+  spec: specOf52("touch"),
+  fn: touchCommand,
+  write: true
+});
+
+// src/commands/builtin/opfs/tr.ts
+import { ResourceName as ResourceName56, command as command53, specOf as specOf53, trGeneric } from "@struktoai/mirage-core";
+var OPFS_TR = command53({
+  name: "tr",
+  resource: ResourceName56.OPFS,
+  spec: specOf53("tr"),
+  fn: (accessor, paths, texts, opts) => trGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/tree.ts
+import { ResourceName as ResourceName57, command as command54, specOf as specOf54, treeGeneric } from "@struktoai/mirage-core";
+var OPFS_TREE = command54({
+  name: "tree",
+  resource: ResourceName57.OPFS,
+  spec: specOf54("tree"),
+  fn: (accessor, paths, _texts, opts) => treeGeneric(
+    paths,
+    opts,
+    (p) => readdir(accessor, p),
+    (p) => stat(accessor, p)
+  )
+});
+
+// src/commands/builtin/opfs/tsort.ts
+import { ResourceName as ResourceName58, command as command55, specOf as specOf55, tsortGeneric } from "@struktoai/mirage-core";
+var OPFS_TSORT = command55({
+  name: "tsort",
+  resource: ResourceName58.OPFS,
+  spec: specOf55("tsort"),
+  fn: (accessor, paths, _texts, opts) => tsortGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/unexpand.ts
+import { ResourceName as ResourceName59, command as command56, specOf as specOf56, unexpandGeneric } from "@struktoai/mirage-core";
+var OPFS_UNEXPAND = command56({
+  name: "unexpand",
+  resource: ResourceName59.OPFS,
+  spec: specOf56("unexpand"),
+  fn: (accessor, paths, _texts, opts) => unexpandGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/uniq.ts
+import { ResourceName as ResourceName60, command as command57, specOf as specOf57, uniqGeneric } from "@struktoai/mirage-core";
+var OPFS_UNIQ = command57({
+  name: "uniq",
+  resource: ResourceName60.OPFS,
+  spec: specOf57("uniq"),
+  fn: (accessor, paths, _texts, opts) => uniqGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/unzip.ts
+import { ResourceName as ResourceName61, command as command58, specOf as specOf58, unzipGeneric } from "@struktoai/mirage-core";
+var OPFS_UNZIP = command58({
+  name: "unzip",
+  resource: ResourceName61.OPFS,
+  spec: specOf58("unzip"),
+  fn: (accessor, paths, _texts, opts) => unzipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d),
+    (p, parents) => mkdir(accessor, p, parents)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/wc/wc.ts
+import { ResourceName as ResourceName62, command as command59, specOf as specOf59, wcAggregate, wcGeneric } from "@struktoai/mirage-core";
+var OPFS_WC = command59({
+  name: "wc",
+  resource: ResourceName62.OPFS,
+  spec: specOf59("wc"),
+  fn: (accessor, paths, texts, opts) => wcGeneric(paths, texts, opts, (p) => stream(accessor, p)),
+  aggregate: wcAggregate
+});
+
+// src/commands/builtin/opfs/xxd.ts
+import { ResourceName as ResourceName63, command as command60, specOf as specOf60, xxdGeneric } from "@struktoai/mirage-core";
+var OPFS_XXD = command60({
+  name: "xxd",
+  resource: ResourceName63.OPFS,
+  spec: specOf60("xxd"),
+  fn: (accessor, paths, _texts, opts) => xxdGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/zcat.ts
+import { ResourceName as ResourceName64, command as command61, specOf as specOf61, zcatGeneric } from "@struktoai/mirage-core";
+var OPFS_ZCAT = command61({
+  name: "zcat",
+  resource: ResourceName64.OPFS,
+  spec: specOf61("zcat"),
+  fn: (accessor, paths, _texts, opts) => zcatGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/zgrep.ts
+import { ResourceName as ResourceName65, command as command62, specOf as specOf62, zgrepGeneric } from "@struktoai/mirage-core";
+var OPFS_ZGREP = command62({
+  name: "zgrep",
+  resource: ResourceName65.OPFS,
+  spec: specOf62("zgrep"),
+  fn: (accessor, paths, texts, opts) => zgrepGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/opfs/zip_cmd.ts
+import { ResourceName as ResourceName66, command as command63, specOf as specOf63, zipGeneric } from "@struktoai/mirage-core";
+var OPFS_ZIP = command63({
+  name: "zip",
+  resource: ResourceName66.OPFS,
+  spec: specOf63("zip"),
+  fn: (accessor, paths, _texts, opts) => zipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/opfs/index.ts
+var OPFS_COMMANDS = [
+  ...makeFiletypeCommands({
+    resource: ResourceName67.OPFS,
+    readBytes: read,
+    statEntry: stat
+  }),
+  ...OPFS_AWK,
+  ...OPFS_BASE64,
+  ...OPFS_BASENAME,
+  ...OPFS_CAT,
+  ...OPFS_CMP,
+  ...OPFS_COLUMN,
+  ...OPFS_COMM,
+  ...OPFS_CP,
+  ...OPFS_CSPLIT,
+  ...OPFS_CUT,
+  ...OPFS_DIFF,
+  ...OPFS_DIRNAME,
+  ...OPFS_DU,
+  ...OPFS_EXPAND,
+  ...OPFS_FILE,
+  ...OPFS_FIND,
+  ...OPFS_FMT,
+  ...OPFS_FOLD,
+  ...OPFS_GREP,
+  ...OPFS_GUNZIP,
+  ...OPFS_GZIP,
+  ...OPFS_HEAD,
+  ...OPFS_ICONV,
+  ...OPFS_JOIN,
+  ...OPFS_JQ,
+  ...OPFS_LN,
+  ...OPFS_LOOK,
+  ...OPFS_LS,
+  ...OPFS_MD5,
+  ...OPFS_MKDIR,
+  ...OPFS_MKTEMP,
+  ...OPFS_MV,
+  ...OPFS_NL,
+  ...OPFS_PASTE,
+  ...OPFS_PATCH,
+  ...OPFS_READLINK,
+  ...OPFS_REALPATH,
+  ...OPFS_REV,
+  ...OPFS_RG,
+  ...OPFS_RM,
+  ...OPFS_SED,
+  ...OPFS_SHA256SUM,
+  ...OPFS_SHUF,
+  ...OPFS_SORT,
+  ...OPFS_SPLIT,
+  ...OPFS_STAT,
+  ...OPFS_STRINGS,
+  ...OPFS_TAC,
+  ...OPFS_TAIL,
+  ...OPFS_TAR,
+  ...OPFS_TEE,
+  ...OPFS_TOUCH,
+  ...OPFS_TR,
+  ...OPFS_TREE,
+  ...OPFS_TSORT,
+  ...OPFS_UNEXPAND,
+  ...OPFS_UNIQ,
+  ...OPFS_UNZIP,
+  ...OPFS_WC,
+  ...OPFS_XXD,
+  ...OPFS_ZCAT,
+  ...OPFS_ZGREP,
+  ...OPFS_ZIP
+];
+
+// src/core/opfs/append.ts
+import { record as record3, ResourceName as ResourceName68 } from "@struktoai/mirage-core";
+async function appendBytes(accessor, p, data) {
+  const root = accessor.rootHandle;
+  const start = performance.now();
+  const virtual = p.stripPrefix;
+  const handle = await resolveFileHandle(root, virtual, { create: true });
+  const existing = await handle.getFile();
+  const existingBytes = new Uint8Array(await existing.arrayBuffer());
+  const merged = new Uint8Array(existingBytes.byteLength + data.byteLength);
+  merged.set(existingBytes, 0);
+  merged.set(data, existingBytes.byteLength);
+  const writable = await handle.createWritable();
+  await writable.write(toWritableChunk(merged));
+  await writable.close();
+  record3("append", virtual, ResourceName68.OPFS, data.byteLength, start);
+}
+
+// src/core/opfs/glob.ts
+import { PathSpec } from "@struktoai/mirage-core";
+
+// src/core/opfs/constants.ts
+var SCOPE_ERROR = 5e4;
+
+// src/core/opfs/glob.ts
+import { fnmatch } from "@struktoai/mirage-core";
+import { gnuBasename as gnuBasename2 } from "@struktoai/mirage-core";
+async function resolveGlob(accessor, paths) {
+  const result = [];
+  for (const p of paths) {
+    if (p.resolved) {
+      result.push(p);
+    } else if (p.pattern !== null) {
+      const dirSpec = new PathSpec({
+        original: p.directory,
+        directory: p.directory,
+        resolved: true,
+        prefix: p.prefix
+      });
+      const entries = await readdir(accessor, dirSpec);
+      const matched = [];
+      for (const e of entries) {
+        if (fnmatch(gnuBasename2(e), p.pattern)) {
+          matched.push(
+            new PathSpec({
+              original: e,
+              directory: p.directory,
+              resolved: true,
+              prefix: p.prefix
+            })
+          );
+        }
+      }
+      if (matched.length > SCOPE_ERROR) matched.length = SCOPE_ERROR;
+      result.push(...matched);
+    } else {
+      result.push(p);
+    }
+  }
+  return result;
+}
+
+// src/core/opfs/truncate.ts
+async function truncate(accessor, path, length) {
+  const root = accessor.rootHandle;
+  const virtual = path.stripPrefix;
+  let handle;
+  let existing;
+  try {
+    handle = await resolveFileHandle(root, virtual, { create: false });
+    const file = await handle.getFile();
+    existing = new Uint8Array(await file.arrayBuffer());
+  } catch (err) {
+    if (isNotFound(err)) {
+      handle = await resolveFileHandle(root, virtual, { create: true });
+      existing = new Uint8Array();
+    } else {
+      throw err;
+    }
+  }
+  const out = new Uint8Array(length);
+  out.set(existing.subarray(0, Math.min(existing.byteLength, length)));
+  const writable = await handle.createWritable();
+  await writable.write(toWritableChunk(out));
+  await writable.close();
+}
+
+// src/ops/opfs/append.ts
+import { ResourceName as ResourceName69 } from "@struktoai/mirage-core";
+var appendOp = {
+  name: "append",
+  resource: ResourceName69.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const data = args[0];
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("append op requires a Uint8Array as the first arg");
+    }
+    return appendBytes(accessor, path, data);
+  }
+};
+
+// src/ops/opfs/create.ts
+import { ResourceName as ResourceName70 } from "@struktoai/mirage-core";
+
+// src/core/opfs/create.ts
+function create(accessor, path) {
+  return writeBytes(accessor, path, new Uint8Array());
+}
+
+// src/ops/opfs/create.ts
+var createOp = {
+  name: "create",
+  resource: ResourceName70.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => create(accessor, path)
+};
+
+// src/ops/opfs/mkdir.ts
+import { ResourceName as ResourceName71 } from "@struktoai/mirage-core";
+var mkdirOp = {
+  name: "mkdir",
+  resource: ResourceName71.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => mkdir(accessor, path, true)
+};
+
+// src/ops/opfs/read.ts
+import { ResourceName as ResourceName72 } from "@struktoai/mirage-core";
+var readOp = {
+  name: "read",
+  resource: ResourceName72.OPFS,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => read(accessor, path)
+};
+
+// src/ops/opfs/readdir.ts
+import { ResourceName as ResourceName73 } from "@struktoai/mirage-core";
+var readdirOp = {
+  name: "readdir",
+  resource: ResourceName73.OPFS,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => readdir(accessor, path)
+};
+
+// src/ops/opfs/rename.ts
+import { ResourceName as ResourceName74 } from "@struktoai/mirage-core";
+var renameOp = {
+  name: "rename",
+  resource: ResourceName74.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const dst = args[0];
+    if (dst === void 0 || dst === null || typeof dst !== "object" || !("original" in dst)) {
+      throw new TypeError("rename op requires a PathSpec destination as the first arg");
+    }
+    return rename(accessor, path, dst);
+  }
+};
+
+// src/ops/opfs/rmdir.ts
+import { ResourceName as ResourceName75 } from "@struktoai/mirage-core";
+var rmdirOp = {
+  name: "rmdir",
+  resource: ResourceName75.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => rmdir(accessor, path)
+};
+
+// src/ops/opfs/stat.ts
+import { ResourceName as ResourceName76 } from "@struktoai/mirage-core";
+var statOp = {
+  name: "stat",
+  resource: ResourceName76.OPFS,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => stat(accessor, path)
+};
+
+// src/ops/opfs/truncate.ts
+import { ResourceName as ResourceName77 } from "@struktoai/mirage-core";
+var truncateOp = {
+  name: "truncate",
+  resource: ResourceName77.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const length = args[0];
+    if (typeof length !== "number") {
+      throw new TypeError("truncate op requires a number length as the first arg");
+    }
+    return truncate(accessor, path, length);
+  }
+};
+
+// src/ops/opfs/unlink.ts
+import { ResourceName as ResourceName78 } from "@struktoai/mirage-core";
+var unlinkOp = {
+  name: "unlink",
+  resource: ResourceName78.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => unlink(accessor, path)
+};
+
+// src/ops/opfs/write.ts
+import { ResourceName as ResourceName79 } from "@struktoai/mirage-core";
+var writeOp = {
+  name: "write",
+  resource: ResourceName79.OPFS,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const data = args[0];
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("write op requires a Uint8Array as the first arg");
+    }
+    return writeBytes(accessor, path, data);
+  }
+};
+
+// src/ops/opfs/index.ts
+var OPFS_OPS = [
+  appendOp,
+  createOp,
+  mkdirOp,
+  readOp,
+  readdirOp,
+  renameOp,
+  rmdirOp,
+  statOp,
+  truncateOp,
+  unlinkOp,
+  writeOp
+];
+
+// src/resource/opfs/prompt.ts
+var OPFS_PROMPT = `{prefix}
+  Browser Origin Private File System. Persistent per-origin storage that survives page reloads.
+  Standard commands: ls, cat, head, tail, grep, wc, find, tree, mkdir, touch, cp, mv, rm, tee.`;
+
+// src/resource/opfs/opfs.ts
+async function walkFiles(dir, currentPath, files) {
+  for await (const [name, handle] of iterEntries(dir)) {
+    const childPath = currentPath === "" ? name : `${currentPath}/${name}`;
+    if (handle.kind === "file") {
+      const fh = await dir.getFileHandle(name, { create: false });
+      const file = await fh.getFile();
+      files[childPath] = new Uint8Array(await file.arrayBuffer());
+    } else {
+      const child = await dir.getDirectoryHandle(name, { create: false });
+      await walkFiles(child, childPath, files);
+    }
+  }
+}
+async function walkDirs(dir, currentPath, dirs) {
+  for await (const [name, handle] of iterEntries(dir)) {
+    if (handle.kind !== "directory") continue;
+    const childPath = currentPath === "" ? `/${name}` : `${currentPath}/${name}`;
+    dirs.push(childPath);
+    const child = await dir.getDirectoryHandle(name, { create: false });
+    await walkDirs(child, childPath, dirs);
+  }
+}
+async function splitAndCreate(root, relativePath) {
+  let handle = root;
+  for (const seg of relativePath.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    handle = await handle.getDirectoryHandle(seg, { create: true });
+  }
+  return handle;
+}
+var OPFSResource = class {
+  kind = ResourceName80.OPFS;
+  prompt = OPFS_PROMPT;
+  rootName;
+  accessor;
+  rootHandle = null;
+  openPromise = null;
+  constructor(options = {}) {
+    this.rootName = options.root ?? "";
+    this.accessor = new OPFSAccessor(this);
+  }
+  open() {
+    return this.ensureOpen().then(() => void 0);
+  }
+  close() {
+    this.rootHandle = null;
+    this.openPromise = null;
+    return Promise.resolve();
+  }
+  /**
+   * Lazily resolve to a usable root handle. Memoizes `navigator.storage`
+   * traversal so the resource self-initializes on first method call without
+   * relying on an external orchestrator.
+   */
+  ensureOpen() {
+    if (this.rootHandle !== null) return Promise.resolve(this.rootHandle);
+    this.openPromise ??= (async () => {
+      const origin = await navigator.storage.getDirectory();
+      let handle = origin;
+      for (const seg of this.rootName.split("/")) {
+        if (seg === "" || seg === ".") continue;
+        handle = await handle.getDirectoryHandle(seg, { create: true });
+      }
+      this.rootHandle = handle;
+      return handle;
+    })();
+    return this.openPromise;
+  }
+  requireHandle() {
+    if (this.rootHandle === null) {
+      throw new Error("OPFSResource is not open \u2014 call open() first");
+    }
+    return this.rootHandle;
+  }
+  ops() {
+    return OPFS_OPS;
+  }
+  commands() {
+    return OPFS_COMMANDS;
+  }
+  async *streamPath(p) {
+    await this.ensureOpen();
+    yield* stream(this.accessor, p);
+  }
+  async readFile(p) {
+    await this.ensureOpen();
+    return read(this.accessor, p);
+  }
+  async writeFile(p, data) {
+    await this.ensureOpen();
+    return writeBytes(this.accessor, p, data);
+  }
+  async appendFile(p, data) {
+    await this.ensureOpen();
+    return appendBytes(this.accessor, p, data);
+  }
+  async readdir(p) {
+    await this.ensureOpen();
+    return readdir(this.accessor, p);
+  }
+  async stat(p) {
+    await this.ensureOpen();
+    return stat(this.accessor, p);
+  }
+  async exists(p) {
+    await this.ensureOpen();
+    return exists(this.accessor, p);
+  }
+  async mkdir(p, options) {
+    await this.ensureOpen();
+    return mkdir(this.accessor, p, options?.recursive === true);
+  }
+  async rmdir(p) {
+    await this.ensureOpen();
+    return rmdir(this.accessor, p);
+  }
+  async unlink(p) {
+    await this.ensureOpen();
+    return unlink(this.accessor, p);
+  }
+  async rename(src, dst) {
+    await this.ensureOpen();
+    return rename(this.accessor, src, dst);
+  }
+  async truncate(p, length) {
+    await this.ensureOpen();
+    return truncate(this.accessor, p, length);
+  }
+  async copy(src, dst) {
+    await this.ensureOpen();
+    return copy(this.accessor, src, dst);
+  }
+  async rmR(p) {
+    await this.ensureOpen();
+    return rmR(this.accessor, p);
+  }
+  async du(p) {
+    await this.ensureOpen();
+    return du(this.accessor, p);
+  }
+  async find(p, options = {}) {
+    await this.ensureOpen();
+    return find(this.accessor, p, options);
+  }
+  async glob(paths) {
+    await this.ensureOpen();
+    return resolveGlob(this.accessor, paths);
+  }
+  async getState() {
+    const handle = await this.ensureOpen();
+    const files = {};
+    await walkFiles(handle, "", files);
+    const dirs = [];
+    await walkDirs(handle, "", dirs);
+    dirs.sort();
+    return {
+      type: this.kind,
+      files,
+      dirs
+    };
+  }
+  async loadState(state) {
+    const handle = await this.ensureOpen();
+    for (const dir of state.dirs) {
+      const rel = lstripSlash(dir);
+      if (rel === "") continue;
+      await splitAndCreate(handle, rel);
+    }
+    for (const [rel, data] of Object.entries(state.files)) {
+      const segs = rel.split("/").filter((s) => s !== "" && s !== ".");
+      const fileName = segs.pop();
+      if (fileName === void 0) continue;
+      let dir = handle;
+      for (const seg of segs) {
+        dir = await dir.getDirectoryHandle(seg, { create: true });
+      }
+      const fh = await dir.getFileHandle(fileName, { create: true });
+      const writable = await fh.createWritable();
+      await writable.write(toWritableChunk(data));
+      await writable.close();
+    }
+  }
+};
+
+export {
+  OPFSAccessor,
+  OPFS_COMMANDS,
+  OPFS_OPS,
+  OPFS_PROMPT,
+  OPFSResource
+};
+//# sourceMappingURL=chunk-SJB2KXDM.js.map