@struktoai/mirage-browser 0.0.3 → 0.0.4

package/dist/{chunk-KV2DM5H6.js → chunk-4YUYQTRN.js}

@@ -1,7 +1,8 @@
 // src/resource/opfs/opfs.ts
 import {
-  ResourceName as ResourceName80,
-  lstripSlash
+  ResourceName as ResourceName86,
+  lstripSlash,
+  makeResolveGlob as makeResolveGlob2
 } from "@struktoai/mirage-core";
 
 // src/accessor/opfs.ts
@@ -18,11 +19,19 @@ var OPFSAccessor = class extends Accessor {
 };
 
 // src/commands/builtin/opfs/index.ts
-import { makeFiletypeCommands, ResourceName as ResourceName67 } from "@struktoai/mirage-core";
+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 { enoent } from "@struktoai/mirage-core";
+import { eisdir, enoent } from "@struktoai/mirage-core";
 
 // src/core/opfs/utils.ts
 import { norm, parent, gnuBasename } from "@struktoai/mirage-core";
@@ -95,12 +104,13 @@ async function* iterEntries(dir) {
 async function read(accessor, path) {
   const root = accessor.rootHandle;
   const start = performance.now();
-  const virtual = path.stripPrefix;
+  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();
@@ -109,12 +119,38 @@ async function read(accessor, path) {
   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.stripPrefix;
+  const virtual = p.mountPath;
   const segs = splitSegments(virtual);
   const last = segs.at(-1);
   if (last === void 0) {
@@ -177,15 +213,16 @@ import { ResourceName as ResourceName3, awkGeneric, command, specOf } from "@str
 
 // src/core/opfs/stream.ts
 import { recordStream, ResourceName as ResourceName2 } from "@struktoai/mirage-core";
-import { enoent as enoent3 } 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.stripPrefix;
+  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();
@@ -226,14 +263,7 @@ var OPFS_BASENAME = command3({
 });
 
 // src/commands/builtin/opfs/cat/cat.ts
-import {
-  ResourceName as ResourceName6,
-  catGeneric,
-  catProvisionGeneric,
-  command as command4,
-  concatAggregate,
-  specOf as specOf4
-} from "@struktoai/mirage-core";
+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,
@@ -245,7 +275,6 @@ var OPFS_CAT = command4({
     (p) => stat(accessor, p),
     (p) => stream(accessor, p)
   ),
-  provision: (accessor, paths, _texts, _opts) => catProvisionGeneric(paths, (p) => stat(accessor, p)),
   aggregate: concatAggregate
 });
 
@@ -290,14 +319,14 @@ async function copy(accessor, src, dst) {
   const root = accessor.rootHandle;
   let srcHandle;
   try {
-    srcHandle = await resolveFileHandle(root, src.stripPrefix, { create: false });
+    srcHandle = await resolveFileHandle(root, src.mountPath, { create: false });
   } catch (err) {
-    if (isNotFound(err)) throw new Error(`file not found: ${src.stripPrefix}`);
+    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.stripPrefix, { create: true });
+  const dstHandle = await resolveFileHandle(root, dst.mountPath, { create: true });
   const writable = await dstHandle.createWritable();
   await writable.write(toWritableChunk(data));
   await writable.close();
@@ -351,6 +380,10 @@ async function walk(ctx, dir, current, depth) {
     )) {
       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 });
@@ -382,8 +415,8 @@ async function walk(ctx, dir, current, depth) {
 }
 async function find(accessor, p, options = {}) {
   const root = accessor.rootHandle;
-  const virtual = norm(p.stripPrefix);
-  const startName = startBasename(p.original);
+  const virtual = norm(p.mountPath);
+  const startName = startBasename(p.virtual);
   const results = [];
   const tree = options.tree ?? buildTree({
     name: options.name,
@@ -417,7 +450,9 @@ async function find(accessor, p, options = {}) {
       exists: true,
       tree,
       maxDepth: options.maxDepth,
-      minDepth: options.minDepth
+      minDepth: options.minDepth,
+      minSize: options.minSize,
+      maxSize: options.maxSize
     });
   }
   await walk({ options, tree, results }, dir, virtual, 0);
@@ -436,9 +471,11 @@ function cpCommand(accessor, paths, _texts, opts) {
   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),
+    {
+      copy: (src, target) => copy(accessor, src, target),
+      find: (src, options) => find(accessor, src, options)
+    },
     recursive,
     opts.flags.n === true,
     opts.flags.v === true,
@@ -461,7 +498,7 @@ import { record as record2, ResourceName as ResourceName11 } from "@struktoai/mi
 async function writeBytes(accessor, p, data) {
   const root = accessor.rootHandle;
   const start = performance.now();
-  const virtual = p.stripPrefix;
+  const virtual = p.mountPath;
   const handle = await resolveFileHandle(root, virtual, { create: true });
   const writable = await handle.createWritable();
   await writable.write(toWritableChunk(data));
@@ -495,33 +532,6 @@ var OPFS_CUT = command10({
 
 // src/commands/builtin/opfs/diff.ts
 import { ResourceName as ResourceName14, command as command11, diffGeneric, specOf as specOf11 } 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/diff.ts
 var OPFS_DIFF = command11({
   name: "diff",
   resource: ResourceName14.OPFS,
@@ -618,11 +628,11 @@ async function sizeOfPath(root, virtual) {
   }
 }
 async function du(accessor, p) {
-  return sizeOfPath(accessor.rootHandle, p.stripPrefix);
+  return sizeOfPath(accessor.rootHandle, p.mountPath);
 }
 async function duAll(accessor, p) {
   const root = accessor.rootHandle;
-  const virtual = norm(p.stripPrefix);
+  const virtual = norm(p.mountPath);
   const entries = [];
   try {
     const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
@@ -751,7 +761,7 @@ import { ResourceName as ResourceName23, command as command20, specOf as specOf2
 // src/core/opfs/unlink.ts
 async function unlink(accessor, path) {
   const root = accessor.rootHandle;
-  const virtual = path.stripPrefix;
+  const virtual = path.mountPath;
   let parentDir;
   let name;
   try {
@@ -802,14 +812,7 @@ var OPFS_GZIP = command21({
 });
 
 // src/commands/builtin/opfs/head/head.ts
-import {
-  ResourceName as ResourceName25,
-  command as command22,
-  headGeneric,
-  headProvisionGeneric,
-  headerAggregate,
-  specOf as specOf22
-} from "@struktoai/mirage-core";
+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,
@@ -821,7 +824,6 @@ var OPFS_HEAD = command22({
     (p) => stat(accessor, p),
     (p) => stream(accessor, p)
   ),
-  provision: (accessor, paths, texts, opts) => headProvisionGeneric(paths, texts, opts, (p) => stat(accessor, p)),
   aggregate: headerAggregate
 });
 
@@ -850,19 +852,12 @@ var OPFS_JOIN = command24({
 });
 
 // src/commands/builtin/opfs/jq.ts
-import {
-  ResourceName as ResourceName28,
-  command as command25,
-  jqGeneric,
-  jqProvisionGeneric,
-  specOf as specOf25
-} from "@struktoai/mirage-core";
+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)),
-  provision: (accessor, paths, texts, _opts) => jqProvisionGeneric(paths, texts, (p) => stat(accessor, p))
+  fn: (accessor, paths, texts, opts) => jqGeneric(paths, texts, opts, (p) => stream(accessor, p))
 });
 
 // src/commands/builtin/opfs/ln.ts
@@ -877,7 +872,7 @@ import {
 // src/core/opfs/exists.ts
 async function exists(accessor, path) {
   const root = accessor.rootHandle;
-  const virtual = path.stripPrefix;
+  const virtual = path.mountPath;
   if (virtual === "/" || virtual === "") return true;
   try {
     const [parentDir, name] = await resolveParentDirHandle(root, virtual, { create: false });
@@ -930,9 +925,9 @@ async function lnCommand(accessor, paths, texts, opts) {
   }
   const data = await materialize(stream(accessor, source));
   await writeBytes(accessor, dest, data);
-  const out = opts.flags.v === true ? ENC.encode(`'${source.original}' -> '${dest.original}'
+  const out = opts.flags.v === true ? ENC.encode(`'${source.virtual}' -> '${dest.virtual}'
 `) : null;
-  return [out, new IOResult2({ writes: { [dest.stripPrefix]: data } })];
+  return [out, new IOResult2({ writes: { [dest.mountPath]: data } })];
 }
 var OPFS_LN = command26({
   name: "ln",
@@ -957,12 +952,11 @@ 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)
-  )
+  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
@@ -974,22 +968,35 @@ var OPFS_MD5 = command29({
   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 ResourceName33,
-  command as command30,
-  specOf as specOf30
+  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.stripPrefix;
+  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;
@@ -1020,6 +1027,7 @@ async function mkdir(accessor, path, parents = false) {
 // 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,
@@ -1029,25 +1037,28 @@ async function mkdirCommand(accessor, paths, texts, opts) {
       })
     ];
   }
+  const lines = [];
   for (const p of paths) {
     await mkdir(accessor, p, parents);
+    if (verbose) lines.push(`mkdir: created directory '${p.virtual.replace(/\/+$/, "") || "/"}'`);
   }
-  return [null, new IOResult3()];
+  const output = verbose && lines.length > 0 ? formatRecords(lines) : null;
+  return [output, new IOResult3()];
 }
-var OPFS_MKDIR = command30({
+var OPFS_MKDIR = command31({
   name: "mkdir",
-  resource: ResourceName33.OPFS,
-  spec: specOf30("mkdir"),
+  resource: ResourceName34.OPFS,
+  spec: specOf31("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({
+import { ResourceName as ResourceName35, command as command32, mktempGeneric, specOf as specOf32 } from "@struktoai/mirage-core";
+var OPFS_MKTEMP = command32({
   name: "mktemp",
-  resource: ResourceName34.OPFS,
-  spec: specOf31("mktemp"),
+  resource: ResourceName35.OPFS,
+  spec: specOf32("mktemp"),
   fn: (accessor, _paths, texts, opts) => mktempGeneric(
     texts,
     opts,
@@ -1060,10 +1071,10 @@ var OPFS_MKTEMP = command31({
 // src/commands/builtin/opfs/mv.ts
 import {
   IOResult as IOResult4,
-  ResourceName as ResourceName35,
-  command as command32,
+  ResourceName as ResourceName36,
+  command as command33,
   mvGeneric,
-  specOf as specOf32
+  specOf as specOf33
 } from "@struktoai/mirage-core";
 
 // src/core/opfs/rename.ts
@@ -1086,8 +1097,8 @@ async function copyDirRecursive(root, srcPath, dstPath) {
 }
 async function rename(accessor, src, dst) {
   const root = accessor.rootHandle;
-  const srcPath = src.stripPrefix;
-  const dstPath = dst.stripPrefix;
+  const srcPath = src.mountPath;
+  const dstPath = dst.mountPath;
   let srcParent;
   let srcName;
   try {
@@ -1139,45 +1150,45 @@ function mvCommand(accessor, paths, _texts, opts) {
   }
   return mvGeneric(
     paths,
-    (src, target) => rename(accessor, src, target),
     (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 = command32({
+var OPFS_MV = command33({
   name: "mv",
-  resource: ResourceName35.OPFS,
-  spec: specOf32("mv"),
+  resource: ResourceName36.OPFS,
+  spec: specOf33("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({
+import { ResourceName as ResourceName37, command as command34, specOf as specOf34, nlGeneric } from "@struktoai/mirage-core";
+var OPFS_NL = command34({
   name: "nl",
-  resource: ResourceName36.OPFS,
-  spec: specOf33("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 ResourceName37, command as command34, specOf as specOf34, pasteGeneric } from "@struktoai/mirage-core";
-var OPFS_PASTE = command34({
+import { ResourceName as ResourceName38, command as command35, specOf as specOf35, pasteGeneric } from "@struktoai/mirage-core";
+var OPFS_PASTE = command35({
   name: "paste",
-  resource: ResourceName37.OPFS,
-  spec: specOf34("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 ResourceName38, command as command35, specOf as specOf35, patchGeneric } from "@struktoai/mirage-core";
-var OPFS_PATCH = command35({
+import { ResourceName as ResourceName39, command as command36, specOf as specOf36, patchGeneric } from "@struktoai/mirage-core";
+var OPFS_PATCH = command36({
   name: "patch",
-  resource: ResourceName38.OPFS,
-  spec: specOf35("patch"),
+  resource: ResourceName39.OPFS,
+  spec: specOf36("patch"),
   fn: (accessor, paths, _texts, opts) => patchGeneric(
     paths,
     opts,
@@ -1189,42 +1200,42 @@ var OPFS_PATCH = command35({
 
 // src/commands/builtin/opfs/readlink.ts
 import {
-  ResourceName as ResourceName39,
-  command as command36,
+  ResourceName as ResourceName40,
+  command as command37,
   readlinkGeneric,
-  specOf as specOf36
+  specOf as specOf37
 } from "@struktoai/mirage-core";
-var OPFS_READLINK = command36({
+var OPFS_READLINK = command37({
   name: "readlink",
-  resource: ResourceName39.OPFS,
-  spec: specOf36("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 ResourceName40, command as command37, realpathGeneric, specOf as specOf37 } from "@struktoai/mirage-core";
-var OPFS_REALPATH = command37({
+import { ResourceName as ResourceName41, command as command38, realpathGeneric, specOf as specOf38 } from "@struktoai/mirage-core";
+var OPFS_REALPATH = command38({
   name: "realpath",
-  resource: ResourceName40.OPFS,
-  spec: specOf37("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 ResourceName41, command as command38, specOf as specOf38, revGeneric } from "@struktoai/mirage-core";
-var OPFS_REV = command38({
+import { ResourceName as ResourceName42, command as command39, specOf as specOf39, revGeneric } from "@struktoai/mirage-core";
+var OPFS_REV = command39({
   name: "rev",
-  resource: ResourceName41.OPFS,
-  spec: specOf38("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 ResourceName42, command as command39, rgGeneric, specOf as specOf39 } from "@struktoai/mirage-core";
-var OPFS_RG = command39({
+import { ResourceName as ResourceName43, command as command40, rgGeneric, specOf as specOf40 } from "@struktoai/mirage-core";
+var OPFS_RG = command40({
   name: "rg",
-  resource: ResourceName42.OPFS,
-  spec: specOf39("rg"),
+  resource: ResourceName43.OPFS,
+  spec: specOf40("rg"),
   fn: (accessor, paths, texts, opts) => rgGeneric(
     paths,
     texts,
@@ -1239,15 +1250,18 @@ var OPFS_RG = command39({
 import {
   FileType as FileType2,
   IOResult as IOResult5,
-  ResourceName as ResourceName43,
-  command as command40,
-  specOf as specOf40
+  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.stripPrefix;
+  const virtual = path.mountPath;
   let parentDir;
   let name;
   try {
@@ -1269,7 +1283,7 @@ async function rmdir(accessor, path) {
 // src/core/opfs/rm.ts
 async function rmR(accessor, path) {
   const root = accessor.rootHandle;
-  const virtual = path.stripPrefix;
+  const virtual = path.mountPath;
   let parentDir;
   let name;
   try {
@@ -1300,75 +1314,244 @@ async function rmCommand(accessor, paths, texts, opts) {
     ];
   }
   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 {
-      isDir = false;
+      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 {
+      } 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(/\/+$/, "") || "/"}'`];
     }
-  }
-  return [null, new IOResult5()];
+    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 = command40({
+var OPFS_RM = command41({
   name: "rm",
-  resource: ResourceName43.OPFS,
-  spec: specOf40("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 { ResourceName as ResourceName44, makeSed } from "@struktoai/mirage-core";
-var OPFS_SED = makeSed({
-  resource: ResourceName44.OPFS,
-  stream: (a, p) => stream(a, p),
-  write: (a, p, d) => writeBytes(a, p, d)
+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 ResourceName45, command as command41, sha256sumGeneric, specOf as specOf41 } from "@struktoai/mirage-core";
-var OPFS_SHA256SUM = command41({
+import { ResourceName as ResourceName48, command as command45, sha256sumGeneric, specOf as specOf45 } from "@struktoai/mirage-core";
+var OPFS_SHA256SUM = command45({
   name: "sha256sum",
-  resource: ResourceName45.OPFS,
-  spec: specOf41("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 ResourceName46, command as command42, specOf as specOf42, shufGeneric } from "@struktoai/mirage-core";
-var OPFS_SHUF = command42({
+import { ResourceName as ResourceName51, command as command48, specOf as specOf48, shufGeneric } from "@struktoai/mirage-core";
+var OPFS_SHUF = command48({
   name: "shuf",
-  resource: ResourceName46.OPFS,
-  spec: specOf42("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 ResourceName47, command as command43, specOf as specOf43, sortGeneric } from "@struktoai/mirage-core";
-var OPFS_SORT = command43({
+import { ResourceName as ResourceName52, command as command49, specOf as specOf49, sortGeneric } from "@struktoai/mirage-core";
+var OPFS_SORT = command49({
   name: "sort",
-  resource: ResourceName47.OPFS,
-  spec: specOf43("sort"),
-  fn: (accessor, paths, _texts, opts) => sortGeneric(paths, opts, (p) => stream(accessor, p))
+  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 ResourceName48, command as command44, specOf as specOf44, splitGeneric } from "@struktoai/mirage-core";
-var OPFS_SPLIT = command44({
+import { ResourceName as ResourceName53, command as command50, specOf as specOf50, splitGeneric } from "@struktoai/mirage-core";
+var OPFS_SPLIT = command50({
   name: "split",
-  resource: ResourceName48.OPFS,
-  spec: specOf44("split"),
+  resource: ResourceName53.OPFS,
+  spec: specOf50("split"),
   fn: (accessor, paths, _texts, opts) => splitGeneric(
     paths,
     opts,
@@ -1379,55 +1562,48 @@ var OPFS_SPLIT = command44({
 });
 
 // src/commands/builtin/opfs/stat/stat.ts
-import {
-  ResourceName as ResourceName49,
-  command as command45,
-  specOf as specOf45,
-  statGeneric,
-  statProvisionGeneric
-} from "@struktoai/mirage-core";
-var OPFS_STAT = command45({
+import { ResourceName as ResourceName54, command as command51, specOf as specOf51, statGeneric } from "@struktoai/mirage-core";
+var OPFS_STAT = command51({
   name: "stat",
-  resource: ResourceName49.OPFS,
-  spec: specOf45("stat"),
-  fn: (accessor, paths, _texts, opts) => statGeneric(paths, opts, (p) => stat(accessor, p)),
-  provision: statProvisionGeneric
+  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 ResourceName50, command as command46, specOf as specOf46, stringsGeneric } from "@struktoai/mirage-core";
-var OPFS_STRINGS = command46({
+import { ResourceName as ResourceName55, command as command52, specOf as specOf52, stringsGeneric } from "@struktoai/mirage-core";
+var OPFS_STRINGS = command52({
   name: "strings",
-  resource: ResourceName50.OPFS,
-  spec: specOf46("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 ResourceName51, command as command47, specOf as specOf47, tacGeneric } from "@struktoai/mirage-core";
-var OPFS_TAC = command47({
+import { ResourceName as ResourceName56, command as command53, specOf as specOf53, tacGeneric } from "@struktoai/mirage-core";
+var OPFS_TAC = command53({
   name: "tac",
-  resource: ResourceName51.OPFS,
-  spec: specOf47("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 ResourceName52, command as command48, headerAggregate as headerAggregate2, specOf as specOf48, tailGeneric } from "@struktoai/mirage-core";
-var OPFS_TAIL = command48({
+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: ResourceName52.OPFS,
-  spec: specOf48("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 ResourceName53, command as command49, specOf as specOf49, tarGeneric } from "@struktoai/mirage-core";
-var OPFS_TAR = command49({
+import { ResourceName as ResourceName58, command as command55, specOf as specOf55, tarGeneric } from "@struktoai/mirage-core";
+var OPFS_TAR = command55({
   name: "tar",
-  resource: ResourceName53.OPFS,
-  spec: specOf49("tar"),
+  resource: ResourceName58.OPFS,
+  spec: specOf55("tar"),
   fn: (accessor, paths, _texts, opts) => tarGeneric(
     paths,
     opts,
@@ -1439,11 +1615,11 @@ var OPFS_TAR = command49({
 });
 
 // src/commands/builtin/opfs/tee.ts
-import { ResourceName as ResourceName54, command as command50, specOf as specOf50, teeGeneric } from "@struktoai/mirage-core";
-var OPFS_TEE = command50({
+import { ResourceName as ResourceName59, command as command56, specOf as specOf56, teeGeneric } from "@struktoai/mirage-core";
+var OPFS_TEE = command56({
   name: "tee",
-  resource: ResourceName54.OPFS,
-  spec: specOf50("tee"),
+  resource: ResourceName59.OPFS,
+  spec: specOf56("tee"),
   fn: (accessor, paths, texts, opts) => teeGeneric(
     paths,
     texts,
@@ -1456,15 +1632,15 @@ var OPFS_TEE = command50({
 
 // src/commands/builtin/opfs/touch.ts
 import {
-  IOResult as IOResult6,
-  ResourceName as ResourceName55,
-  command as command51,
-  specOf as specOf51
+  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 IOResult6({ exitCode: 1, stderr: ENC2.encode("touch: missing operand\n") })];
+    return [null, new IOResult7({ exitCode: 1, stderr: ENC2.encode("touch: missing operand\n") })];
   }
   const createOnly = opts.flags.c === true;
   for (const p of paths) {
@@ -1473,31 +1649,31 @@ async function touchCommand(accessor, paths, texts, opts) {
       await writeBytes(accessor, p, new Uint8Array(0));
     }
   }
-  return [null, new IOResult6()];
+  return [null, new IOResult7()];
 }
-var OPFS_TOUCH = command51({
+var OPFS_TOUCH = command57({
   name: "touch",
-  resource: ResourceName55.OPFS,
-  spec: specOf51("touch"),
+  resource: ResourceName60.OPFS,
+  spec: specOf57("touch"),
   fn: touchCommand,
   write: true
 });
 
 // src/commands/builtin/opfs/tr.ts
-import { ResourceName as ResourceName56, command as command52, specOf as specOf52, trGeneric } from "@struktoai/mirage-core";
-var OPFS_TR = command52({
+import { ResourceName as ResourceName61, command as command58, specOf as specOf58, trGeneric } from "@struktoai/mirage-core";
+var OPFS_TR = command58({
   name: "tr",
-  resource: ResourceName56.OPFS,
-  spec: specOf52("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 ResourceName57, command as command53, specOf as specOf53, treeGeneric } from "@struktoai/mirage-core";
-var OPFS_TREE = command53({
+import { ResourceName as ResourceName62, command as command59, specOf as specOf59, treeGeneric } from "@struktoai/mirage-core";
+var OPFS_TREE = command59({
   name: "tree",
-  resource: ResourceName57.OPFS,
-  spec: specOf53("tree"),
+  resource: ResourceName62.OPFS,
+  spec: specOf59("tree"),
   fn: (accessor, paths, _texts, opts) => treeGeneric(
     paths,
     opts,
@@ -1507,38 +1683,111 @@ var OPFS_TREE = command53({
 });
 
 // src/commands/builtin/opfs/tsort.ts
-import { ResourceName as ResourceName58, command as command54, specOf as specOf54, tsortGeneric } from "@struktoai/mirage-core";
-var OPFS_TSORT = command54({
+import { ResourceName as ResourceName63, command as command60, specOf as specOf60, tsortGeneric } from "@struktoai/mirage-core";
+var OPFS_TSORT = command60({
   name: "tsort",
-  resource: ResourceName58.OPFS,
-  spec: specOf54("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 ResourceName59, command as command55, specOf as specOf55, unexpandGeneric } from "@struktoai/mirage-core";
-var OPFS_UNEXPAND = command55({
+import { ResourceName as ResourceName64, command as command61, specOf as specOf61, unexpandGeneric } from "@struktoai/mirage-core";
+var OPFS_UNEXPAND = command61({
   name: "unexpand",
-  resource: ResourceName59.OPFS,
-  spec: specOf55("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 ResourceName60, command as command56, specOf as specOf56, uniqGeneric } from "@struktoai/mirage-core";
-var OPFS_UNIQ = command56({
+import { ResourceName as ResourceName65, command as command62, specOf as specOf62, uniqGeneric } from "@struktoai/mirage-core";
+var OPFS_UNIQ = command62({
   name: "uniq",
-  resource: ResourceName60.OPFS,
-  spec: specOf56("uniq"),
-  fn: (accessor, paths, _texts, opts) => uniqGeneric(paths, opts, (p) => stream(accessor, p))
+  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 ResourceName61, command as command57, specOf as specOf57, unzipGeneric } from "@struktoai/mirage-core";
-var OPFS_UNZIP = command57({
+import { ResourceName as ResourceName67, command as command64, specOf as specOf64, unzipGeneric } from "@struktoai/mirage-core";
+var OPFS_UNZIP = command64({
   name: "unzip",
-  resource: ResourceName61.OPFS,
-  spec: specOf57("unzip"),
+  resource: ResourceName67.OPFS,
+  spec: specOf64("unzip"),
   fn: (accessor, paths, _texts, opts) => unzipGeneric(
     paths,
     opts,
@@ -1550,48 +1799,48 @@ var OPFS_UNZIP = command57({
 });
 
 // src/commands/builtin/opfs/wc/wc.ts
-import { ResourceName as ResourceName62, command as command58, specOf as specOf58, wcAggregate, wcGeneric } from "@struktoai/mirage-core";
-var OPFS_WC = command58({
+import { ResourceName as ResourceName68, command as command65, specOf as specOf65, wcAggregate, wcGeneric } from "@struktoai/mirage-core";
+var OPFS_WC = command65({
   name: "wc",
-  resource: ResourceName62.OPFS,
-  spec: specOf58("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 ResourceName63, command as command59, specOf as specOf59, xxdGeneric } from "@struktoai/mirage-core";
-var OPFS_XXD = command59({
+import { ResourceName as ResourceName69, command as command66, specOf as specOf66, xxdGeneric } from "@struktoai/mirage-core";
+var OPFS_XXD = command66({
   name: "xxd",
-  resource: ResourceName63.OPFS,
-  spec: specOf59("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 ResourceName64, command as command60, specOf as specOf60, zcatGeneric } from "@struktoai/mirage-core";
-var OPFS_ZCAT = command60({
+import { ResourceName as ResourceName70, command as command67, specOf as specOf67, zcatGeneric } from "@struktoai/mirage-core";
+var OPFS_ZCAT = command67({
   name: "zcat",
-  resource: ResourceName64.OPFS,
-  spec: specOf60("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 ResourceName65, command as command61, specOf as specOf61, zgrepGeneric } from "@struktoai/mirage-core";
-var OPFS_ZGREP = command61({
+import { ResourceName as ResourceName71, command as command68, specOf as specOf68, zgrepGeneric } from "@struktoai/mirage-core";
+var OPFS_ZGREP = command68({
   name: "zgrep",
-  resource: ResourceName65.OPFS,
-  spec: specOf61("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 ResourceName66, command as command62, specOf as specOf62, zipGeneric } from "@struktoai/mirage-core";
-var OPFS_ZIP = command62({
+import { ResourceName as ResourceName72, command as command69, specOf as specOf69, zipGeneric } from "@struktoai/mirage-core";
+var OPFS_ZIP = command69({
   name: "zip",
-  resource: ResourceName66.OPFS,
-  spec: specOf62("zip"),
+  resource: ResourceName72.OPFS,
+  spec: specOf69("zip"),
   fn: (accessor, paths, _texts, opts) => zipGeneric(
     paths,
     opts,
@@ -1602,83 +1851,95 @@ var OPFS_ZIP = command62({
 });
 
 // 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
-];
+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 ResourceName68 } from "@struktoai/mirage-core";
+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.stripPrefix;
+  const virtual = p.mountPath;
   const handle = await resolveFileHandle(root, virtual, { create: true });
   const existing = await handle.getFile();
   const existingBytes = new Uint8Array(await existing.arrayBuffer());
@@ -1688,57 +1949,13 @@ async function appendBytes(accessor, p, data) {
   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;
+  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.stripPrefix;
+  const virtual = path.mountPath;
   let handle;
   let existing;
   try {
@@ -1761,10 +1978,10 @@ async function truncate(accessor, path, length) {
 }
 
 // src/ops/opfs/append.ts
-import { ResourceName as ResourceName69 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName75 } from "@struktoai/mirage-core";
 var appendOp = {
   name: "append",
-  resource: ResourceName69.OPFS,
+  resource: ResourceName75.OPFS,
   filetype: null,
   write: true,
   fn: (accessor, path, args) => {
@@ -1777,7 +1994,7 @@ var appendOp = {
 };
 
 // src/ops/opfs/create.ts
-import { ResourceName as ResourceName70 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName76 } from "@struktoai/mirage-core";
 
 // src/core/opfs/create.ts
 function create(accessor, path) {
@@ -1787,52 +2004,52 @@ function create(accessor, path) {
 // src/ops/opfs/create.ts
 var createOp = {
   name: "create",
-  resource: ResourceName70.OPFS,
+  resource: ResourceName76.OPFS,
   filetype: null,
   write: true,
   fn: (accessor, path) => create(accessor, path)
 };
 
 // src/ops/opfs/mkdir.ts
-import { ResourceName as ResourceName71 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName77 } from "@struktoai/mirage-core";
 var mkdirOp = {
   name: "mkdir",
-  resource: ResourceName71.OPFS,
+  resource: ResourceName77.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";
+import { ResourceName as ResourceName78 } from "@struktoai/mirage-core";
 var readOp = {
   name: "read",
-  resource: ResourceName72.OPFS,
+  resource: ResourceName78.OPFS,
   filetype: null,
   write: false,
   fn: (accessor, path) => read(accessor, path)
 };
 
 // src/ops/opfs/readdir.ts
-import { ResourceName as ResourceName73 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName79 } from "@struktoai/mirage-core";
 var readdirOp = {
   name: "readdir",
-  resource: ResourceName73.OPFS,
+  resource: ResourceName79.OPFS,
   filetype: null,
   write: false,
   fn: (accessor, path) => readdir(accessor, path)
 };
 
 // src/ops/opfs/rename.ts
-import { ResourceName as ResourceName74 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName80 } from "@struktoai/mirage-core";
 var renameOp = {
   name: "rename",
-  resource: ResourceName74.OPFS,
+  resource: ResourceName80.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)) {
+    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);
@@ -1840,30 +2057,30 @@ var renameOp = {
 };
 
 // src/ops/opfs/rmdir.ts
-import { ResourceName as ResourceName75 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName81 } from "@struktoai/mirage-core";
 var rmdirOp = {
   name: "rmdir",
-  resource: ResourceName75.OPFS,
+  resource: ResourceName81.OPFS,
   filetype: null,
   write: true,
   fn: (accessor, path) => rmdir(accessor, path)
 };
 
 // src/ops/opfs/stat.ts
-import { ResourceName as ResourceName76 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName82 } from "@struktoai/mirage-core";
 var statOp = {
   name: "stat",
-  resource: ResourceName76.OPFS,
+  resource: ResourceName82.OPFS,
   filetype: null,
   write: false,
   fn: (accessor, path) => stat(accessor, path)
 };
 
 // src/ops/opfs/truncate.ts
-import { ResourceName as ResourceName77 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName83 } from "@struktoai/mirage-core";
 var truncateOp = {
   name: "truncate",
-  resource: ResourceName77.OPFS,
+  resource: ResourceName83.OPFS,
   filetype: null,
   write: true,
   fn: (accessor, path, args) => {
@@ -1876,20 +2093,20 @@ var truncateOp = {
 };
 
 // src/ops/opfs/unlink.ts
-import { ResourceName as ResourceName78 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName84 } from "@struktoai/mirage-core";
 var unlinkOp = {
   name: "unlink",
-  resource: ResourceName78.OPFS,
+  resource: ResourceName84.OPFS,
   filetype: null,
   write: true,
   fn: (accessor, path) => unlink(accessor, path)
 };
 
 // src/ops/opfs/write.ts
-import { ResourceName as ResourceName79 } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName85 } from "@struktoai/mirage-core";
 var writeOp = {
   name: "write",
-  resource: ResourceName79.OPFS,
+  resource: ResourceName85.OPFS,
   filetype: null,
   write: true,
   fn: (accessor, path, args) => {
@@ -1922,6 +2139,7 @@ var OPFS_PROMPT = `{prefix}
   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}`;
@@ -1953,7 +2171,7 @@ async function splitAndCreate(root, relativePath) {
   return handle;
 }
 var OPFSResource = class {
-  kind = ResourceName80.OPFS;
+  kind = ResourceName86.OPFS;
   prompt = OPFS_PROMPT;
   rootName;
   accessor;
@@ -2068,7 +2286,7 @@ var OPFSResource = class {
   }
   async glob(paths) {
     await this.ensureOpen();
-    return resolveGlob(this.accessor, paths);
+    return globCore(this.accessor, paths);
   }
   async getState() {
     const handle = await this.ensureOpen();
@@ -2113,4 +2331,4 @@ export {
   OPFS_PROMPT,
   OPFSResource
 };
-//# sourceMappingURL=chunk-KV2DM5H6.js.map
+//# sourceMappingURL=chunk-4YUYQTRN.js.map