@struktoai/mirage-browser 0.0.4 → 0.0.5

package/dist/chunk-4YUYQTRN.js

@@ -1,2334 +0,0 @@
-// src/resource/opfs/opfs.ts
-import {
-  ResourceName as ResourceName86,
-  lstripSlash,
-  makeResolveGlob as makeResolveGlob2
-} 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,
-  makeResolveGlob,
-  ResourceName as ResourceName73,
-  withDefaultProvisions
-} from "@struktoai/mirage-core";
-
-// src/core/opfs/constants.ts
-var SCOPE_ERROR = 5e4;
-
-// src/core/opfs/read.ts
-import { record, ResourceName } from "@struktoai/mirage-core";
-import { eisdir, 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.mountPath;
-  let handle;
-  try {
-    handle = await resolveFileHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent(path);
-    if (err instanceof DOMException && err.name === "TypeMismatchError") throw eisdir(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/readdir.ts
-import { mountPrefixOf } from "@struktoai/mirage-core";
-import { enotdir } from "@struktoai/mirage-core";
-async function readdir(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.pattern !== null ? path.directory : path.mountPath;
-  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 = mountPrefixOf(path.virtual, path.resourcePath);
-  return names.map((n) => `${mountPrefix}${dirPrefix}${n}`).sort();
-}
-
-// 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.mountPath;
-  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;
-    }
-  }
-  let dirHandle;
-  try {
-    dirHandle = await resolveDirHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent2(p);
-    throw err;
-  }
-  let latest = 0;
-  for await (const [, handle] of iterEntries(dirHandle)) {
-    if (handle.kind !== "file") continue;
-    const file = await handle.getFile();
-    if (file.lastModified > latest) latest = file.lastModified;
-  }
-  return new FileStat({
-    name,
-    size: null,
-    modified: latest > 0 ? new Date(latest).toISOString() : null,
-    type: FileType.DIRECTORY
-  });
-}
-
-// 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 { eisdir as eisdir2, enoent as enoent3 } from "@struktoai/mirage-core";
-async function* stream(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  let handle;
-  try {
-    handle = await resolveFileHandle(root, virtual, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw enoent3(path);
-    if (err instanceof DOMException && err.name === "TypeMismatchError") throw eisdir2(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, 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)
-  ),
-  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.mountPath, { create: false });
-  } catch (err) {
-    if (isNotFound(err)) throw new Error(`file not found: ${src.mountPath}`);
-    throw err;
-  }
-  const file = await srcHandle.getFile();
-  const data = new Uint8Array(await file.arrayBuffer());
-  const dstHandle = await resolveFileHandle(root, dst.mountPath, { create: true });
-  const writable = await dstHandle.createWritable();
-  await writable.write(toWritableChunk(data));
-  await writable.close();
-}
-
-// src/core/opfs/find.ts
-import {
-  buildTree,
-  emitStartPath,
-  keep,
-  startBasename
-} 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)) {
-      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 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.mountPath);
-  const startName = startBasename(p.virtual);
-  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 (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;
-      }
-    }
-    emitStartPath(results, virtual, startName, {
-      kind: "d",
-      isEmpty: rootEmpty,
-      exists: true,
-      tree,
-      maxDepth: options.maxDepth,
-      minDepth: options.minDepth,
-      minSize: options.minSize,
-      maxSize: options.maxSize
-    });
-  }
-  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,
-    (p) => stat(accessor, p),
-    {
-      copy: (src, target) => copy(accessor, src, target),
-      find: (src, options) => find(accessor, src, options)
-    },
-    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.mountPath;
-  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),
-    (p) => readdir(accessor, p),
-    (p) => stat(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.mountPath);
-}
-async function duAll(accessor, p) {
-  const root = accessor.rootHandle;
-  const virtual = norm(p.mountPath);
-  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";
-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.mountPath;
-  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, 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)
-  ),
-  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, 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))
-});
-
-// 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.mountPath;
-  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.virtual}' -> '${dest.virtual}'
-`) : null;
-  return [out, new IOResult2({ writes: { [dest.mountPath]: 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) => {
-    const overlay = opts.statOverlay;
-    const stat2 = overlay !== void 0 ? async (p) => overlay(p.virtual, await stat(accessor, p)) : (p) => stat(accessor, p);
-    return lsGeneric(paths, opts, (p) => readdir(accessor, p), stat2);
-  }
-});
-
-// 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/md5sum.ts
-import { ResourceName as ResourceName33, command as command30, md5sumGeneric, specOf as specOf30 } from "@struktoai/mirage-core";
-var OPFS_MD5SUM = command30({
-  name: "md5sum",
-  resource: ResourceName33.OPFS,
-  spec: specOf30("md5sum"),
-  fn: (accessor, paths, _texts, opts) => md5sumGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/mkdir.ts
-import {
-  IOResult as IOResult3,
-  ResourceName as ResourceName34,
-  command as command31,
-  formatRecords,
-  specOf as specOf31
-} from "@struktoai/mirage-core";
-
-// src/core/opfs/mkdir.ts
-import { invalidateAfterWrite, invalidateAncestors } from "@struktoai/mirage-core";
-async function mkdir(accessor, path, parents = false) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  const segs = splitSegments(virtual);
-  if (segs.length === 0) return;
-  if (parents) {
-    await resolveDirHandle(root, virtual, { create: true });
-    await invalidateAfterWrite(path);
-    await invalidateAncestors(path);
-    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;
-  const verbose = opts.flags.v === true;
-  if (paths.length === 0) {
-    return [
-      null,
-      new IOResult3({
-        exitCode: 1,
-        stderr: new TextEncoder().encode("mkdir: missing operand\n")
-      })
-    ];
-  }
-  const lines = [];
-  for (const p of paths) {
-    await mkdir(accessor, p, parents);
-    if (verbose) lines.push(`mkdir: created directory '${p.virtual.replace(/\/+$/, "") || "/"}'`);
-  }
-  const output = verbose && lines.length > 0 ? formatRecords(lines) : null;
-  return [output, new IOResult3()];
-}
-var OPFS_MKDIR = command31({
-  name: "mkdir",
-  resource: ResourceName34.OPFS,
-  spec: specOf31("mkdir"),
-  fn: mkdirCommand,
-  write: true
-});
-
-// src/commands/builtin/opfs/mktemp.ts
-import { ResourceName as ResourceName35, command as command32, mktempGeneric, specOf as specOf32 } from "@struktoai/mirage-core";
-var OPFS_MKTEMP = command32({
-  name: "mktemp",
-  resource: ResourceName35.OPFS,
-  spec: specOf32("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 ResourceName36,
-  command as command33,
-  mvGeneric,
-  specOf as specOf33
-} 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.mountPath;
-  const dstPath = dst.mountPath;
-  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,
-    (p) => stat(accessor, p),
-    { rename: (src, target) => rename(accessor, src, target) },
-    opts.flags.n === true,
-    opts.flags.v === true,
-    opts.index ?? void 0
-  );
-}
-var OPFS_MV = command33({
-  name: "mv",
-  resource: ResourceName36.OPFS,
-  spec: specOf33("mv"),
-  fn: mvCommand,
-  write: true
-});
-
-// src/commands/builtin/opfs/nl.ts
-import { ResourceName as ResourceName37, command as command34, specOf as specOf34, nlGeneric } from "@struktoai/mirage-core";
-var OPFS_NL = command34({
-  name: "nl",
-  resource: ResourceName37.OPFS,
-  spec: specOf34("nl"),
-  fn: (accessor, paths, _texts, opts) => nlGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/paste.ts
-import { ResourceName as ResourceName38, command as command35, specOf as specOf35, pasteGeneric } from "@struktoai/mirage-core";
-var OPFS_PASTE = command35({
-  name: "paste",
-  resource: ResourceName38.OPFS,
-  spec: specOf35("paste"),
-  fn: (accessor, paths, _texts, opts) => pasteGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/patch.ts
-import { ResourceName as ResourceName39, command as command36, specOf as specOf36, patchGeneric } from "@struktoai/mirage-core";
-var OPFS_PATCH = command36({
-  name: "patch",
-  resource: ResourceName39.OPFS,
-  spec: specOf36("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 ResourceName40,
-  command as command37,
-  readlinkGeneric,
-  specOf as specOf37
-} from "@struktoai/mirage-core";
-var OPFS_READLINK = command37({
-  name: "readlink",
-  resource: ResourceName40.OPFS,
-  spec: specOf37("readlink"),
-  fn: (_accessor, paths, texts, opts) => readlinkGeneric(paths, texts, opts)
-});
-
-// src/commands/builtin/opfs/realpath.ts
-import { ResourceName as ResourceName41, command as command38, realpathGeneric, specOf as specOf38 } from "@struktoai/mirage-core";
-var OPFS_REALPATH = command38({
-  name: "realpath",
-  resource: ResourceName41.OPFS,
-  spec: specOf38("realpath"),
-  fn: (accessor, paths, texts, opts) => realpathGeneric(paths, texts, opts, (p) => stat(accessor, p))
-});
-
-// src/commands/builtin/opfs/rev.ts
-import { ResourceName as ResourceName42, command as command39, specOf as specOf39, revGeneric } from "@struktoai/mirage-core";
-var OPFS_REV = command39({
-  name: "rev",
-  resource: ResourceName42.OPFS,
-  spec: specOf39("rev"),
-  fn: (accessor, paths, _texts, opts) => revGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/rg.ts
-import { ResourceName as ResourceName43, command as command40, rgGeneric, specOf as specOf40 } from "@struktoai/mirage-core";
-var OPFS_RG = command40({
-  name: "rg",
-  resource: ResourceName43.OPFS,
-  spec: specOf40("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 ResourceName44,
-  command as command41,
-  cpWalk,
-  formatRecords as formatRecords2,
-  removalLines,
-  specOf as specOf41
-} from "@struktoai/mirage-core";
-
-// src/core/opfs/rmdir.ts
-async function rmdir(accessor, path) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  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.mountPath;
-  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;
-  const dirFlag = opts.flags.d === true;
-  const force = opts.flags.f === true;
-  const verbose = opts.flags.v === true;
-  const errors = [];
-  const verboseParts = [];
-  const writes = {};
-  for (const p of paths) {
-    let isDir = false;
-    try {
-      const st = await stat(accessor, p);
-      isDir = st.type === FileType2.DIRECTORY;
-    } catch {
-      if (force) continue;
-      errors.push(`rm: cannot remove '${p.virtual}': No such file or directory`);
-      continue;
-    }
-    let entryLines = [];
-    if (isDir) {
-      if (recursive) {
-        if (verbose) {
-          entryLines = removalLines(
-            await cpWalk(
-              (dir) => readdir(accessor, dir),
-              (spec) => stat(accessor, spec),
-              p
-            )
-          );
-        }
-        await rmR(accessor, p);
-      } else if (dirFlag) {
-        if ((await readdir(accessor, p)).length > 0) {
-          errors.push(`rm: cannot remove '${p.virtual}': Directory not empty`);
-          continue;
-        }
-        await rmdir(accessor, p);
-        entryLines = [`removed directory '${p.virtual.replace(/\/+$/, "") || "/"}'`];
-      } else {
-        errors.push(`rm: cannot remove '${p.virtual}': Is a directory`);
-        continue;
-      }
-    } else {
-      await unlink(accessor, p);
-      entryLines = [`removed '${p.virtual.replace(/\/+$/, "") || "/"}'`];
-    }
-    writes[p.mountPath] = new Uint8Array();
-    if (verbose) verboseParts.push(...entryLines);
-  }
-  const output = verbose && verboseParts.length > 0 ? formatRecords2(verboseParts) : null;
-  const stderr = errors.length > 0 ? new TextEncoder().encode(errors.join("\n") + "\n") : void 0;
-  return [
-    output,
-    new IOResult5({
-      writes,
-      exitCode: errors.length > 0 ? 1 : 0,
-      ...stderr !== void 0 ? { stderr } : {}
-    })
-  ];
-}
-var OPFS_RM = command41({
-  name: "rm",
-  resource: ResourceName44.OPFS,
-  spec: specOf41("rm"),
-  fn: rmCommand,
-  write: true
-});
-
-// src/commands/builtin/opfs/rmdir.ts
-import {
-  FileType as FileType3,
-  IOResult as IOResult6,
-  ResourceName as ResourceName45,
-  command as command42,
-  formatRecords as formatRecords3,
-  specOf as specOf42
-} from "@struktoai/mirage-core";
-async function rmdirCommand(accessor, paths, _texts, opts) {
-  const enc = new TextEncoder();
-  if (paths.length === 0) {
-    return [
-      null,
-      new IOResult6({
-        exitCode: 1,
-        stderr: enc.encode("rmdir: missing operand\nTry 'rmdir --help' for more information.\n")
-      })
-    ];
-  }
-  const verbose = opts.flags.v === true;
-  const errors = [];
-  const verboseParts = [];
-  const writes = {};
-  for (const p of paths) {
-    let isDir = false;
-    try {
-      isDir = (await stat(accessor, p)).type === FileType3.DIRECTORY;
-    } catch {
-      errors.push(`rmdir: failed to remove '${p.virtual}': No such file or directory`);
-      continue;
-    }
-    if (!isDir) {
-      errors.push(`rmdir: failed to remove '${p.virtual}': Not a directory`);
-      continue;
-    }
-    if ((await readdir(accessor, p)).length > 0) {
-      errors.push(`rmdir: failed to remove '${p.virtual}': Directory not empty`);
-      continue;
-    }
-    await rmdir(accessor, p);
-    writes[p.mountPath] = new Uint8Array();
-    if (verbose) verboseParts.push(`rmdir: removing directory, '${p.virtual}'`);
-  }
-  const output = verbose && verboseParts.length > 0 ? formatRecords3(verboseParts) : null;
-  const stderr = errors.length > 0 ? enc.encode(errors.join("\n") + "\n") : void 0;
-  return [
-    output,
-    new IOResult6({
-      writes,
-      exitCode: errors.length > 0 ? 1 : 0,
-      ...stderr !== void 0 ? { stderr } : {}
-    })
-  ];
-}
-var OPFS_RMDIR = command42({
-  name: "rmdir",
-  resource: ResourceName45.OPFS,
-  spec: specOf42("rmdir"),
-  fn: rmdirCommand,
-  write: true
-});
-
-// src/commands/builtin/opfs/sed.ts
-import {
-  PathSpec,
-  ResourceName as ResourceName46,
-  command as command43,
-  makeSedProvision,
-  mountKey,
-  resolvePath,
-  rstripSlash,
-  sedGeneric,
-  specOf as specOf43
-} from "@struktoai/mirage-core";
-function positionalAsPaths(texts, opts) {
-  const prefix = opts.mountPrefix !== void 0 ? rstripSlash(opts.mountPrefix) : "";
-  return texts.map((t) => {
-    const resolved = resolvePath(t, opts.cwd);
-    const slash = resolved.lastIndexOf("/");
-    return new PathSpec({
-      virtual: resolved,
-      directory: slash >= 0 ? resolved.slice(0, slash + 1) : "/",
-      resolved: true,
-      resourcePath: mountKey(resolved, prefix)
-    });
-  });
-}
-var OPFS_SED = command43({
-  name: "sed",
-  resource: ResourceName46.OPFS,
-  spec: specOf43("sed"),
-  provision: makeSedProvision((a, p) => stat(a, p)),
-  fn: async (accessor, paths, texts, opts) => {
-    const usingE = opts.flags.e !== void 0 && opts.flags.e !== false;
-    const usingF = opts.flags.f !== void 0 && opts.flags.f !== false;
-    const operands = usingE || usingF ? [...positionalAsPaths(texts, opts), ...paths] : paths;
-    return sedGeneric(
-      operands,
-      texts,
-      opts,
-      (p) => stream(accessor, p),
-      (p, d) => writeBytes(accessor, p, d)
-    );
-  }
-});
-
-// src/commands/builtin/opfs/sha1sum.ts
-import { ResourceName as ResourceName47, command as command44, sha1sumGeneric, specOf as specOf44 } from "@struktoai/mirage-core";
-var OPFS_SHA1SUM = command44({
-  name: "sha1sum",
-  resource: ResourceName47.OPFS,
-  spec: specOf44("sha1sum"),
-  fn: (accessor, paths, _texts, opts) => sha1sumGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/sha256sum.ts
-import { ResourceName as ResourceName48, command as command45, sha256sumGeneric, specOf as specOf45 } from "@struktoai/mirage-core";
-var OPFS_SHA256SUM = command45({
-  name: "sha256sum",
-  resource: ResourceName48.OPFS,
-  spec: specOf45("sha256sum"),
-  fn: (accessor, paths, _texts, opts) => sha256sumGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/sha384sum.ts
-import { ResourceName as ResourceName49, command as command46, sha384sumGeneric, specOf as specOf46 } from "@struktoai/mirage-core";
-var OPFS_SHA384SUM = command46({
-  name: "sha384sum",
-  resource: ResourceName49.OPFS,
-  spec: specOf46("sha384sum"),
-  fn: (accessor, paths, _texts, opts) => sha384sumGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/sha512sum.ts
-import { ResourceName as ResourceName50, command as command47, sha512sumGeneric, specOf as specOf47 } from "@struktoai/mirage-core";
-var OPFS_SHA512SUM = command47({
-  name: "sha512sum",
-  resource: ResourceName50.OPFS,
-  spec: specOf47("sha512sum"),
-  fn: (accessor, paths, _texts, opts) => sha512sumGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/shuf.ts
-import { ResourceName as ResourceName51, command as command48, specOf as specOf48, shufGeneric } from "@struktoai/mirage-core";
-var OPFS_SHUF = command48({
-  name: "shuf",
-  resource: ResourceName51.OPFS,
-  spec: specOf48("shuf"),
-  fn: (accessor, paths, texts, opts) => shufGeneric(paths, texts, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/sort.ts
-import { ResourceName as ResourceName52, command as command49, specOf as specOf49, sortGeneric } from "@struktoai/mirage-core";
-var OPFS_SORT = command49({
-  name: "sort",
-  resource: ResourceName52.OPFS,
-  spec: specOf49("sort"),
-  fn: (accessor, paths, _texts, opts) => sortGeneric(
-    paths,
-    opts,
-    (p) => stream(accessor, p),
-    (p, data) => writeBytes(accessor, p, data)
-  )
-});
-
-// src/commands/builtin/opfs/split.ts
-import { ResourceName as ResourceName53, command as command50, specOf as specOf50, splitGeneric } from "@struktoai/mirage-core";
-var OPFS_SPLIT = command50({
-  name: "split",
-  resource: ResourceName53.OPFS,
-  spec: specOf50("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 ResourceName54, command as command51, specOf as specOf51, statGeneric } from "@struktoai/mirage-core";
-var OPFS_STAT = command51({
-  name: "stat",
-  resource: ResourceName54.OPFS,
-  spec: specOf51("stat"),
-  fn: (accessor, paths, _texts, opts) => statGeneric(paths, opts, (p) => stat(accessor, p))
-});
-
-// src/commands/builtin/opfs/strings.ts
-import { ResourceName as ResourceName55, command as command52, specOf as specOf52, stringsGeneric } from "@struktoai/mirage-core";
-var OPFS_STRINGS = command52({
-  name: "strings",
-  resource: ResourceName55.OPFS,
-  spec: specOf52("strings"),
-  fn: (accessor, paths, _texts, opts) => stringsGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/tac.ts
-import { ResourceName as ResourceName56, command as command53, specOf as specOf53, tacGeneric } from "@struktoai/mirage-core";
-var OPFS_TAC = command53({
-  name: "tac",
-  resource: ResourceName56.OPFS,
-  spec: specOf53("tac"),
-  fn: (accessor, paths, _texts, opts) => tacGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/tail/tail.ts
-import { ResourceName as ResourceName57, command as command54, headerAggregate as headerAggregate2, specOf as specOf54, tailGeneric } from "@struktoai/mirage-core";
-var OPFS_TAIL = command54({
-  name: "tail",
-  resource: ResourceName57.OPFS,
-  spec: specOf54("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 ResourceName58, command as command55, specOf as specOf55, tarGeneric } from "@struktoai/mirage-core";
-var OPFS_TAR = command55({
-  name: "tar",
-  resource: ResourceName58.OPFS,
-  spec: specOf55("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 ResourceName59, command as command56, specOf as specOf56, teeGeneric } from "@struktoai/mirage-core";
-var OPFS_TEE = command56({
-  name: "tee",
-  resource: ResourceName59.OPFS,
-  spec: specOf56("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 IOResult7,
-  ResourceName as ResourceName60,
-  command as command57,
-  specOf as specOf57
-} from "@struktoai/mirage-core";
-var ENC2 = new TextEncoder();
-async function touchCommand(accessor, paths, texts, opts) {
-  if (paths.length === 0) {
-    return [null, new IOResult7({ 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 IOResult7()];
-}
-var OPFS_TOUCH = command57({
-  name: "touch",
-  resource: ResourceName60.OPFS,
-  spec: specOf57("touch"),
-  fn: touchCommand,
-  write: true
-});
-
-// src/commands/builtin/opfs/tr.ts
-import { ResourceName as ResourceName61, command as command58, specOf as specOf58, trGeneric } from "@struktoai/mirage-core";
-var OPFS_TR = command58({
-  name: "tr",
-  resource: ResourceName61.OPFS,
-  spec: specOf58("tr"),
-  fn: (accessor, paths, texts, opts) => trGeneric(paths, texts, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/tree.ts
-import { ResourceName as ResourceName62, command as command59, specOf as specOf59, treeGeneric } from "@struktoai/mirage-core";
-var OPFS_TREE = command59({
-  name: "tree",
-  resource: ResourceName62.OPFS,
-  spec: specOf59("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 ResourceName63, command as command60, specOf as specOf60, tsortGeneric } from "@struktoai/mirage-core";
-var OPFS_TSORT = command60({
-  name: "tsort",
-  resource: ResourceName63.OPFS,
-  spec: specOf60("tsort"),
-  fn: (accessor, paths, _texts, opts) => tsortGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/unexpand.ts
-import { ResourceName as ResourceName64, command as command61, specOf as specOf61, unexpandGeneric } from "@struktoai/mirage-core";
-var OPFS_UNEXPAND = command61({
-  name: "unexpand",
-  resource: ResourceName64.OPFS,
-  spec: specOf61("unexpand"),
-  fn: (accessor, paths, _texts, opts) => unexpandGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/uniq.ts
-import { ResourceName as ResourceName65, command as command62, specOf as specOf62, uniqGeneric } from "@struktoai/mirage-core";
-var OPFS_UNIQ = command62({
-  name: "uniq",
-  resource: ResourceName65.OPFS,
-  spec: specOf62("uniq"),
-  fn: (accessor, paths, _texts, opts) => uniqGeneric(
-    paths,
-    opts,
-    (p) => stream(accessor, p),
-    (p, data) => writeBytes(accessor, p, data)
-  )
-});
-
-// src/commands/builtin/opfs/unlink.ts
-import {
-  FileType as FileType4,
-  IOResult as IOResult8,
-  ResourceName as ResourceName66,
-  command as command63,
-  specOf as specOf63
-} from "@struktoai/mirage-core";
-async function unlinkCommand(accessor, paths, _texts, _opts) {
-  const enc = new TextEncoder();
-  if (paths.length === 0) {
-    return [
-      null,
-      new IOResult8({
-        exitCode: 1,
-        stderr: enc.encode("unlink: missing operand\nTry 'unlink --help' for more information.\n")
-      })
-    ];
-  }
-  if (paths.length > 1) {
-    const extra = paths[1];
-    const raw = extra === void 0 ? "" : extra.rawPath;
-    return [
-      null,
-      new IOResult8({
-        exitCode: 1,
-        stderr: enc.encode(
-          `unlink: extra operand '${raw}'
-Try 'unlink --help' for more information.
-`
-        )
-      })
-    ];
-  }
-  const p = paths[0];
-  if (p === void 0) return [null, new IOResult8()];
-  try {
-    if ((await stat(accessor, p)).type === FileType4.DIRECTORY) {
-      return [
-        null,
-        new IOResult8({
-          exitCode: 1,
-          stderr: enc.encode(`unlink: cannot unlink '${p.virtual}': Is a directory
-`)
-        })
-      ];
-    }
-  } catch {
-    return [
-      null,
-      new IOResult8({
-        exitCode: 1,
-        stderr: enc.encode(`unlink: cannot unlink '${p.virtual}': No such file or directory
-`)
-      })
-    ];
-  }
-  await unlink(accessor, p);
-  return [null, new IOResult8({ writes: { [p.mountPath]: new Uint8Array() } })];
-}
-var OPFS_UNLINK = command63({
-  name: "unlink",
-  resource: ResourceName66.OPFS,
-  spec: specOf63("unlink"),
-  fn: unlinkCommand,
-  write: true
-});
-
-// src/commands/builtin/opfs/unzip.ts
-import { ResourceName as ResourceName67, command as command64, specOf as specOf64, unzipGeneric } from "@struktoai/mirage-core";
-var OPFS_UNZIP = command64({
-  name: "unzip",
-  resource: ResourceName67.OPFS,
-  spec: specOf64("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 ResourceName68, command as command65, specOf as specOf65, wcAggregate, wcGeneric } from "@struktoai/mirage-core";
-var OPFS_WC = command65({
-  name: "wc",
-  resource: ResourceName68.OPFS,
-  spec: specOf65("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 ResourceName69, command as command66, specOf as specOf66, xxdGeneric } from "@struktoai/mirage-core";
-var OPFS_XXD = command66({
-  name: "xxd",
-  resource: ResourceName69.OPFS,
-  spec: specOf66("xxd"),
-  fn: (accessor, paths, _texts, opts) => xxdGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/zcat.ts
-import { ResourceName as ResourceName70, command as command67, specOf as specOf67, zcatGeneric } from "@struktoai/mirage-core";
-var OPFS_ZCAT = command67({
-  name: "zcat",
-  resource: ResourceName70.OPFS,
-  spec: specOf67("zcat"),
-  fn: (accessor, paths, _texts, opts) => zcatGeneric(paths, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/zgrep.ts
-import { ResourceName as ResourceName71, command as command68, specOf as specOf68, zgrepGeneric } from "@struktoai/mirage-core";
-var OPFS_ZGREP = command68({
-  name: "zgrep",
-  resource: ResourceName71.OPFS,
-  spec: specOf68("zgrep"),
-  fn: (accessor, paths, texts, opts) => zgrepGeneric(paths, texts, opts, (p) => stream(accessor, p))
-});
-
-// src/commands/builtin/opfs/zip_cmd.ts
-import { ResourceName as ResourceName72, command as command69, specOf as specOf69, zipGeneric } from "@struktoai/mirage-core";
-var OPFS_ZIP = command69({
-  name: "zip",
-  resource: ResourceName72.OPFS,
-  spec: specOf69("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 opfsResolveGlob = makeResolveGlob(readdir, SCOPE_ERROR);
-var OPFS_COMMANDS = withDefaultProvisions(
-  [
-    ...makeFiletypeCommands({
-      resource: ResourceName73.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_MD5SUM,
-    ...OPFS_MKDIR,
-    ...OPFS_MKTEMP,
-    ...OPFS_MV,
-    ...OPFS_NL,
-    ...OPFS_PASTE,
-    ...OPFS_PATCH,
-    ...OPFS_READLINK,
-    ...OPFS_REALPATH,
-    ...OPFS_REV,
-    ...OPFS_RG,
-    ...OPFS_RM,
-    ...OPFS_RMDIR,
-    ...OPFS_SED,
-    ...OPFS_SHA1SUM,
-    ...OPFS_SHA256SUM,
-    ...OPFS_SHA384SUM,
-    ...OPFS_SHA512SUM,
-    ...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_UNLINK,
-    ...OPFS_UNZIP,
-    ...OPFS_WC,
-    ...OPFS_XXD,
-    ...OPFS_ZCAT,
-    ...OPFS_ZGREP,
-    ...OPFS_ZIP
-  ],
-  stat,
-  opfsResolveGlob,
-  readdir
-);
-
-// src/core/opfs/append.ts
-import { record as record3, ResourceName as ResourceName74 } from "@struktoai/mirage-core";
-async function appendBytes(accessor, p, data) {
-  const root = accessor.rootHandle;
-  const start = performance.now();
-  const virtual = p.mountPath;
-  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, ResourceName74.OPFS, data.byteLength, start);
-}
-
-// src/core/opfs/truncate.ts
-async function truncate(accessor, path, length) {
-  const root = accessor.rootHandle;
-  const virtual = path.mountPath;
-  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 ResourceName75 } from "@struktoai/mirage-core";
-var appendOp = {
-  name: "append",
-  resource: ResourceName75.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 ResourceName76 } 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: ResourceName76.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => create(accessor, path)
-};
-
-// src/ops/opfs/mkdir.ts
-import { ResourceName as ResourceName77 } from "@struktoai/mirage-core";
-var mkdirOp = {
-  name: "mkdir",
-  resource: ResourceName77.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => mkdir(accessor, path, true)
-};
-
-// src/ops/opfs/read.ts
-import { ResourceName as ResourceName78 } from "@struktoai/mirage-core";
-var readOp = {
-  name: "read",
-  resource: ResourceName78.OPFS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => read(accessor, path)
-};
-
-// src/ops/opfs/readdir.ts
-import { ResourceName as ResourceName79 } from "@struktoai/mirage-core";
-var readdirOp = {
-  name: "readdir",
-  resource: ResourceName79.OPFS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => readdir(accessor, path)
-};
-
-// src/ops/opfs/rename.ts
-import { ResourceName as ResourceName80 } from "@struktoai/mirage-core";
-var renameOp = {
-  name: "rename",
-  resource: ResourceName80.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path, args) => {
-    const dst = args[0];
-    if (dst === void 0 || dst === null || typeof dst !== "object" || !("virtual" 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 ResourceName81 } from "@struktoai/mirage-core";
-var rmdirOp = {
-  name: "rmdir",
-  resource: ResourceName81.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => rmdir(accessor, path)
-};
-
-// src/ops/opfs/stat.ts
-import { ResourceName as ResourceName82 } from "@struktoai/mirage-core";
-var statOp = {
-  name: "stat",
-  resource: ResourceName82.OPFS,
-  filetype: null,
-  write: false,
-  fn: (accessor, path) => stat(accessor, path)
-};
-
-// src/ops/opfs/truncate.ts
-import { ResourceName as ResourceName83 } from "@struktoai/mirage-core";
-var truncateOp = {
-  name: "truncate",
-  resource: ResourceName83.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 ResourceName84 } from "@struktoai/mirage-core";
-var unlinkOp = {
-  name: "unlink",
-  resource: ResourceName84.OPFS,
-  filetype: null,
-  write: true,
-  fn: (accessor, path) => unlink(accessor, path)
-};
-
-// src/ops/opfs/write.ts
-import { ResourceName as ResourceName85 } from "@struktoai/mirage-core";
-var writeOp = {
-  name: "write",
-  resource: ResourceName85.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
-var globCore = makeResolveGlob2(readdir, SCOPE_ERROR);
-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 = ResourceName86.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 globCore(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-4YUYQTRN.js.map