@poe-platform/safe-bash 0.1.800 → 0.1.801

package/README.md

@@ -75,6 +75,8 @@ the default registry’s GH/Git integration; add `ghCommands` explicitly where n
 The registry subpath supports ESM splitting without visiting the full aggregate.
 Its exports do not select the optional
 `op`, `node` or `safejs` plugins; add those only through their command entrypoints.
+Only registered commands are available; adding search commands does not enable unrelated tools.
+Use `agentCommands({ muscleMemory: true })` or individual command plugins to enable tools such as `bc`, `fd`, `sponge`, and `less`.
 Removing a registered command changes availability, while shared family code may
 remain bundled. Splitting dynamic
 imports changes initialization timing: every uploaded static chunk and Wasm asset
@@ -222,7 +224,7 @@ and other unsupported options remain unavailable.
 | --- | --- |
 | Browse | `pwd`, `ls` (including `-i`/`--inode` for provider-reported inode numbers, with `?` for unknown metadata; `-Q`/`--quote-name` and `--indicator-style=none/slash/file-type/classify`), `tree`, `find` (including `-H` to follow argument symlinks while keeping descendant links physical, and `-D tree` for virtual expression diagnostics; other debug modes are unsupported), `du`, `file`, `basename`, `dirname`, `realpath` (including lexical `-s`/`--strip`/`--no-symlinks`), `readlink` (including `-m`/`--canonicalize-missing`), `which` |
 | Files | `mkdir`, `touch`, `cp`, `mv`, `rm`, `rmdir`, `ln`, `chmod`, `stat`, `mktemp`. `mkdir -m` accepts octal and symbolic permission modes; symbolic modes start from `0777` masked by the current umask. `rm --interactive=never` removes without prompting; `--interactive=always` / `-i` reads a confirmation from stdin for each removal. `--interactive=once` / `-I` prompts once for recursive removal or more than three operands. `cp -a` / `--archive` copies directory trees without dereferencing symbolic links (the virtual archive profile is `-RP`; add preservation flags for metadata and hard links). `cp -b` / `--backup[=simple\|numbered\|existing]` preserves replaced files; `-S` / `--suffix` sets the simple backup suffix. `cp -t DIR` / `--target-directory=DIR` copies sources into a directory; `-T` / `--no-target-directory` treats the destination as a single path. `mv -u` / `--update` moves files only when the destination is absent or older; directories retain normal move behavior. `mv -t DIR` / `--target-directory=DIR` moves sources into an existing directory; `-T` / `--no-target-directory` treats the destination as an exact path. `cp --remove-destination` removes destination entries before copying, preserving other hard links and leaving destination symlink referents untouched. `cp --preserve=mode` retains permissions; `-p` retains modes and access/modification times and requires matching reported owners. `-d` copies symlinks and preserves links between copied entries. `--attributes-only` leaves existing bytes intact and creates empty missing files; combine it with preservation flags to update metadata. Unsupported metadata operations fail explicitly; ownership changes and symlink timestamps are unavailable. `cp -v` reports paths using the original operand spelling, including relative paths. `ln -sr` / `--symbolic --relative` computes a relative symlink target from the link directory, resolving existing symlinks and allowing missing sources. `ln -v` / `--verbose` reports each successful link as 'target' => 'source' (hard) or 'target' -> 'source' (symbolic). `rmdir --ignore-fail-on-non-empty` leaves nonempty directories untouched without reporting a failure; with `-p`, removal stops at the first nonempty parent. `touch -h` / `--no-dereference` accepts ordinary files and reads reference symlink metadata; symlink targets fail explicitly because symlink timestamp mutation is unavailable. `touch -d` / `--date` accepts epoch seconds (`@0`), ISO/RFC dates and the virtual `date` relative-date profile; `-t [[CC]YY]MMDDhhmm[.ss]` sets a calendar timestamp. |
-| Filter/search | `cat`, `head`, `tail`, `wc`, `tee`, `cut`, `tr`, `sort`, `uniq`, `sed`, `awk`, `grep`, `rg`, `egrep`, `fgrep`, `fd`. `fd` finds virtual files and directories with regex/glob patterns, extension/type/size/time filters, ignore files, and literal command execution; see [fd usage](../safe-bash-command-fd/README.md). `awk` accepts `--field-separator` (`-F`), `--source` (`-e`), and `--characters-as-bytes` (`-b`); its strings and records are byte-oriented. `cut -c` selects raw bytes in C/POSIX locales (`LC_ALL`, then `LC_CTYPE`, then `LANG`); otherwise it selects UTF-8 characters, including when no locale is set. `head` and `tail` accept `-z` / `--zero-terminated` for NUL-delimited records. `tail --follow[=descriptor\|name]` follows retained files; `--retry` retries inaccessible files (`-F` combines name following and retry). `-s` / `--sleep-interval` sets polling seconds, and `--max-unchanged-stats` controls name reopening after unchanged polls; `--max-idle=0` emits only the initial selection. Following requires retained-read filesystem support. `uniq -D` / `--all-repeated[=none\|prepend\|separate]` prints every repeated record; `--group[=separate\|prepend\|append\|both]` prints all records with group separators. `wc -L` / `--max-line-length` counts display columns with eight-column tab stops; UTF-8 widths use the frozen GNU/Linux C.UTF-8 profile. |
+| Filter/search | `cat`, `head`, `tail`, `wc`, `tee`, `cut`, `tr`, `sort`, `uniq`, `sed`, `awk`, `grep`, `rg`, `egrep`, `fgrep`, `fd`. `fd` finds virtual files and directories with regex/glob patterns, extension/type/size/time filters, ignore files, and literal command execution; see [fd usage](../safe-bash-command-fd/README.md). `awk` accepts `--field-separator` (`-F`), `--source` (`-e`), and `--characters-as-bytes` (`-b`); its string indexes and records are byte-oriented. `sed` and `awk` regexes count UTF-8 characters by default and in UTF-8 locales; C/POSIX locales and `awk -b` select byte matching (locale precedence: `LC_ALL`, `LC_CTYPE`, `LANG`). `cut -c` selects raw bytes in C/POSIX locales (`LC_ALL`, then `LC_CTYPE`, then `LANG`); otherwise it selects UTF-8 characters, including when no locale is set. `head` and `tail` accept `-z` / `--zero-terminated` for NUL-delimited records. `tail --follow[=descriptor\|name]` follows retained files; `--retry` retries inaccessible files (`-F` combines name following and retry). `-s` / `--sleep-interval` sets polling seconds, and `--max-unchanged-stats` controls name reopening after unchanged polls; `--max-idle=0` emits only the initial selection. Following requires retained-read filesystem support. `uniq -D` / `--all-repeated[=none\|prepend\|separate]` prints every repeated record; `--group[=separate\|prepend\|append\|both]` prints all records with group separators. `wc -L` / `--max-line-length` counts display columns with eight-column tab stops; UTF-8 widths use the frozen GNU/Linux C.UTF-8 profile. |
 | Format/combine | `nl`, `seq`, `rev`, `tac`, `expand`, `unexpand`, `fold`, `fmt`, `strings`, `paste`, `comm`, `join`, `column`, `split`, `pr`. `pr --date-format=FORMAT` customizes the UTC header date using the virtual `date` format directives. |
 | Structured text | `jq`, `html-to-markdown`, `xq`, `xmllint`, `mdq`. `mdq` extracts Markdown sections and elements, with Markdown, JSON and plain output; see the [query syntax and limits](../safe-bash-command-mdq/README.md). `xq` converts XML to JSON and applies jq filters. `xmllint` supports `--xpath`, `--noout` well-formedness checks, `--format`, `--noblanks`, `--output` / `-o`, `--recover`, `--encode`, and inclusive/exclusive canonicalization (`--c14n` / `--exc-c14n`) with comments; DTDs and schema validation are unsupported. [XML modes and limits](docs/XML_QUERY.md). `jq` supports ASCII escapes (`-a`), indentation (`--indent`, `--tab`), explicit color (`-C` / `-M`), NUL-delimited raw output (`--raw-output0`), and unbuffered writes. `jq -S` / `--sort-keys` sorts object keys recursively in JSON output; `--stream` / `--stream-errors` emit path events, and `--seq` handles JSON sequences within the same resource limits. `--rawfile NAME FILE` binds virtual-file text; `--slurpfile NAME FILE` binds its JSON values as an array. `--args` and `--jsonargs` expose string or JSON arguments through `$ARGS.positional`. `jq -L DIRECTORY` loads virtual `.jq` modules with zero-argument definitions; see [jq options and limits](src/commands/structured/README.md). |
 | Bytes/checksums | `base64`, `base32`, `xxd`, `od`, `md5sum`, `sha1sum`, `sha256sum`, `cksum`. `od -a` prints ASCII character names, `-f` prints IEEE single-precision floats, and `-i` / `-l` print signed four/eight-byte integers. Explicit float types are `-tf4` and `-tf8`. `od --strings[=MIN]` / `-S[MIN]` prints NUL-terminated strings with at least MIN characters (default 3). |
@@ -390,7 +392,7 @@ unqualified.
 | Command | Plugin and configuration |
 | --- | --- |
 | `dos2unix`, `unix2dos` | `lineEndingCommands({ limits?, replace? })` from `/commands/line-endings`: byte and UTF-16 line-ending conversion. Use `-e` / `--add-eol` to terminate the final line, `-O` / `--to-stdout` to convert without rewriting inputs, and `-i[FLAGS]` / `--info[=FLAGS]` to inspect line endings, BOM and text/binary status. `-v` prints conversion details. In-place conversion requires safe publication capabilities and preserves reported ownership; `--allow-chown` permits publication when ownership cannot be preserved, and `--no-allow-chown` restores the default. |
-| `curl`, `wget` | `networkCommands({ authorize, transport?, limits?, replace? })`: required authorization on every request, redirect, and retry. Curl's `-r/--range` requests byte ranges. Wget supports `--header 'NAME: VALUE'`, `--user-agent`, `--referer`, `--post-data`/`--post-file` and `--method` with `--body-data`/`--body-file`; body files come from the VFS and retain their bytes. Repeated wget headers replace earlier values by name; `--header=''` clears custom headers, and `NAME:` sends an empty value. Transport-controlled headers are rejected, and custom headers are dropped after crossing origins. Node uses the native HTTP transport and supports curl's `--connect-timeout` for DNS/TCP/TLS setup. Workers can inject `createFetchTransport()`, which cannot enforce a separate connection timeout. `createOriginAuthorizer([...])` provides exact origin/hostname policy; its omitted allowlist is deliberately `*` (allow all). [Options and limits](src/commands/network/types.ts). |
+| `curl`, `wget` | `networkCommands({ authorize, transport?, limits?, replace? })`: required authorization on every request, redirect, and retry. Curl's `-r/--range` requests byte ranges. Wget supports `--header 'NAME: VALUE'`, `--user-agent`, `--referer`, `--post-data`/`--post-file` and `--method` with `--body-data`/`--body-file`; body files come from the VFS and retain their bytes. Repeated wget headers replace earlier values by name; `--header=''` clears custom headers, and `NAME:` sends an empty value. Host, Connection, and Expect overrides are accepted; framing and proxy headers remain transport-controlled. Custom headers are dropped after crossing origins. Node uses the native HTTP transport and supports curl's `--connect-timeout` for DNS/TCP/TLS setup. Workers default to `createFetchTransport()`, which cannot enforce a separate connection timeout. Network registration without an authorizer denies requests. Quotas default to disabled in every runtime. `createOriginAuthorizer([...])` provides exact origin/hostname policy; its omitted allowlist is deliberately `*` (allow all). [Options and limits](src/commands/network/types.ts). |
 | `node` | `nodeCommands({ runtime, limits?, replace? })`: runs JavaScript with an injected SafeJS runtime, virtual files, and shell streams. [Usage and supported subset](src/commands/node/README.md). |
 | `python`, `python3` | `pythonCommands({ createExecutor })` from `@poe-platform/safe-bash/commands/python`: supply an explicit executor for invocation-local Python, filesystem I/O and shell streams. Open-file, directory, worker-capacity, input-fragment, package-download, cache and manifest-store quotas are unlimited by default; configure individual budgets when needed. [Executor and ownership contract](src/contracts/python-executor.md). Invocation capabilities include `createPythonLlmCapability(context, service)` for the same authorized model service and `createPythonShellCapability(context)` for enabled commands. The bundled [Python LLM client](docs/python-llm.md) supports canonical streamed attachments, shared named templates and a typed saved-configuration snapshot. |
 | `llm` | `llmCommands({ providers, defaultModel?, replace? })` or `llmCommands({ service, replace? })`: opt-in model routing, sandbox attachments and streamed text/binary output. Includes injected-transport OpenAI and ElevenLabs reference providers. [Configuration and provider contract](src/commands/llm/README.md). |
@@ -639,6 +641,11 @@ one execution. `stdin` accepts a string, `Uint8Array`, or async byte source;
 `stdout`/`stderr` accept byte sinks. Results still buffer output when sinks are
 provided. Pass an `AbortSignal` as `signal` to cancel. [Option types](src/shell/types.ts).
 
+`RANDOM` produces values from 0 through 32767 and accepts a seed for repeatable
+sequences. `SECONDS` tracks elapsed whole seconds and accepts a new starting
+value. Assignments through arithmetic, `read`, and `printf -v` retain these
+behaviors; unsetting either variable removes its special behavior.
+
 Execution quotas are unlimited by default. Set individual `limits` to opt in;
 supplying one does not enable other quotas. Available quotas are `maxParseUnits`,
 `maxInputBytes`, `maxOutputBytes`, `maxCommands`, `maxFileSystemOperations`,
@@ -725,7 +732,8 @@ time/environment commands, metadata, diff/patch, LLM providers, `yes`, `less`,
 `sponge`, `bc`, `htmlq`, `which`, `getopt`, `factor`, and `tsort`
 have unlimited resource budgets by default. Set individual family limits to opt
 in; setting one limit leaves the others unlimited. Explicit `Infinity` also
-disables a limit. Shell helpers expose `maxCdWork`, `maxCdProbes`,
+disables a limit. Standard and agent command factories accept `maxRecursiveDirectoryDepth`
+for recursive filesystem traversal; it defaults to unlimited. Shell helpers expose `maxCdWork`, `maxCdProbes`,
 `maxCdPathBytes`, `maxCdPathComponents`, `maxDirectoryStackEntries`,
 `maxDirectoryStackBytes`, `maxDirectoryDiagnosticBytes`, `maxDirectoryStackOutputBytes`, `maxSyntaxDepth`, `maxAdmittedHandles`, `maxDescriptorOperations`, `maxDescriptorReadBytes`, `maxGlobstarStates`, `maxGlobstarDepth` and
 `maxGlobstarEntries`. Env split limits are supplied through
@@ -737,7 +745,10 @@ navigation, and code execution deadlines are disabled by default; configure
 `limits.actionTimeoutMs`, `limits.codeExecutionTimeoutMs`, or session timeouts
 to bound them. `Infinity` disables host deadlines and maps to the native
 Playwright timeout value `0`. `xargs -s Infinity` and `--max-chars=Infinity` explicitly remove
-the command-size quota. Stream chunk sizes and polling intervals control execution
+the command-size quota. Without `-n`, argument count does not split `xargs` batches;
+command-size and explicit line limits still apply. `-I` followed by `-n 1` preserves
+replacement mode; `-L` and other `-n` values select the last requested batching mode.
+Stream chunk sizes and polling intervals control execution
 independently of these quotas. `diff -u /dev/null FILE` and its reverse produce
 creation/deletion patches; top-level readable character and FIFO inputs are
 read to EOF. Regular files retain identity-checked reads.
@@ -803,7 +814,7 @@ and credential protections remain in effect.
   background jobs/job control, `exec`, process substitution,
   associative arrays, or C-style `for ((…))` loops. `shopt` supports `dotglob`,
   `globstar`, `nullglob`, `nocaseglob`, and `nocasematch`, plus `-o` for supported
-  `set` options. `extglob` can be queried, printed, or unset; enabling it is unsupported.
+  `set` options. `shopt -s extglob` enables extended patterns, including parameter trimming.
 - Utilities implement subsets of their native counterparts' flags and behavior.
   There is no `git`, `npm`, `npx`, or fallback to installed host programs.
   The opt-in `node` command is not a general Node.js runtime.

package/dist/image-ast/index.browser.js

@@ -47901,6 +47901,7 @@ function formatExtractedPageText(page, options = {}) {
       if (Math.abs(dy) > 4) return dy;
       return a.bbox[0] - b.bbox[0];
     });
+    const leftMargin = allLines.reduce((left, line) => Math.min(left, line.bbox[0]), Infinity);
     const rows = [];
     for (const l of allLines) {
       const lastRow = rows[rows.length - 1];
@@ -47914,17 +47915,17 @@ function formatExtractedPageText(page, options = {}) {
       row.sort((a, b) => a.bbox[0] - b.bbox[0]);
       const pitch = options.fixedPitch !== void 0 && options.fixedPitch > 0 ? options.fixedPitch : 6;
       let lineStr = "";
-      let curX = 0;
+      let curX = leftMargin;
       if (options.fixedPitch !== void 0 && options.fixedPitch > 0) {
         const words = row.flatMap((seg) => seg.words).sort((a, b) => a.bbox[0] - b.bbox[0]);
         for (const w of words) {
-          const spaces = Math.max(curX > 0 ? 1 : 0, Math.round((w.bbox[0] - curX) / pitch));
+          const spaces = Math.max(lineStr.length > 0 ? 1 : 0, Math.round((w.bbox[0] - curX) / pitch));
           lineStr += " ".repeat(Math.min(spaces, 80)) + w.text;
           curX = w.bbox[2];
         }
       } else {
         for (const seg of row) {
-          const spaces = Math.max(curX > 0 ? 2 : 0, Math.round((seg.bbox[0] - curX) / pitch));
+          const spaces = Math.max(lineStr.length > 0 ? 2 : 0, Math.round((seg.bbox[0] - curX) / pitch));
           lineStr += " ".repeat(Math.min(spaces, 40)) + seg.text;
           curX = seg.bbox[2];
         }
@@ -57693,16 +57694,31 @@ async function openFileDescriptor(path, options, capabilities, acquire) {
 }
 
 // ../safe-fs/dist/contracts/virtual-path.js
-var MAX_PATH_BYTES = 65536;
-var MAX_PATH_COMPONENTS = 2048;
-function validatePath(path, maxComponents = MAX_PATH_COMPONENTS) {
+function pathByteLength(path) {
+  let bytes = 0;
+  for (const point of path) {
+    const code = point.codePointAt(0);
+    bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function validatePath(path, limits = {}) {
+  const maxBytes = typeof limits === "number" ? Infinity : limits.maxPathBytes ?? Infinity;
+  const maxComponents = typeof limits === "number" ? limits : limits.maxPathComponents ?? Infinity;
+  for (const value of [maxBytes, maxComponents]) {
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
+      throw new RangeError("Path limits must be nonnegative safe integers or Infinity");
+    }
+  }
   if (typeof path !== "string" || path.includes("\0")) {
     throw new FsError("EINVAL", { syscall: "resolve", message: "paths must be strings without NUL bytes" });
   }
-  if (path.length > MAX_PATH_BYTES) {
+  if (maxBytes !== Infinity && pathByteLength(path) > maxBytes) {
     throw new FsError("ENAMETOOLONG", { syscall: "resolve", path });
   }
-  const limit = Math.min(maxComponents, MAX_PATH_COMPONENTS);
+  if (maxComponents === Infinity)
+    return;
+  const limit = maxComponents;
   let components2 = 0;
   let inComponent = false;
   for (let i = 0; i < path.length; i++) {
@@ -58351,11 +58367,14 @@ function components(path, signal) {
   }
   return result;
 }
-function resolveMissingTarget(root, path, signal) {
+function resolveMissingTarget(root, path, signal, limits = {}) {
+  validatePath(path, limits);
   const fail3 = (code, failedPath = path) => {
     throw new FsError(code, { syscall: "realpath", path: failedPath });
   };
   const origin = components(path, signal);
+  let remainingBytes = (limits.maxPathBytes ?? Infinity) - pathByteLength(path);
+  let remainingComponents = (limits.maxPathComponents ?? Infinity) - origin.length;
   const initial = { node: root, name: "" };
   let position = initial;
   let links = 0;
@@ -58408,7 +58427,10 @@ function resolveMissingTarget(root, path, signal) {
       if (node.type === "symlink") {
         if (++links > 40)
           return fail3("ELOOP");
+        validatePath(node.target, { maxPathBytes: remainingBytes, maxPathComponents: remainingComponents });
         const names2 = components(node.target, signal);
+        remainingBytes -= pathByteLength(node.target);
+        remainingComponents -= names2.length;
         if (node.target.endsWith("/"))
           names2.push({ name: ".", start: node.target.length });
         if (node.target.startsWith("/"))
@@ -58612,26 +58634,22 @@ function readConfigRecord(value, label, keys) {
 
 // ../safe-fs/dist/fs/memory/limits.js
 var defaultMemoryFileSystemLimits = Object.freeze({
+  maxPathBytes: Infinity,
+  maxPathComponents: Infinity,
   maxFileBytes: Infinity,
   maxRetainedBytes: Infinity,
   maxMetadataUnits: Infinity
 });
 function normalizeMemoryFileSystemLimits(options) {
-  const keys = ["maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
+  const keys = ["maxPathBytes", "maxPathComponents", "maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
   const record2 = readConfigRecord(options, "memory option", [...keys, "maxBytes"]);
   const limits = { ...defaultMemoryFileSystemLimits };
-  if (Object.hasOwn(record2, "maxBytes") && record2.maxBytes !== void 0) {
-    if (typeof record2.maxBytes !== "number" || !Number.isSafeInteger(record2.maxBytes) || record2.maxBytes < 0) {
-      throw new RangeError("maxBytes must be a nonnegative safe integer");
-    }
-    limits.maxBytes = record2.maxBytes;
-  }
-  for (const key of keys) {
-    if (!Object.hasOwn(record2, key))
-      continue;
+  for (const key of [...keys, "maxBytes"]) {
     const value = record2[key];
+    if (value === void 0 || value === Infinity)
+      continue;
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (key === "maxMetadataUnits" ? 1 : 0)) {
-      throw new RangeError(`${key} must be a ${key === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer`);
+      throw new RangeError(`${key} must be a ${key === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer or Infinity`);
     }
     limits[key] = value;
   }
@@ -58680,12 +58698,10 @@ var DUMMY_POOL_FILE_NODE = new MemoryFileNode(0, 0, null, 0, DUMMY_POOL_ALLOCATI
 DUMMY_POOL_FILE_NODE.atimeMs = DUMMY_POOL_FILE_NODE.mtimeMs = DUMMY_POOL_FILE_NODE.ctimeMs = DUMMY_POOL_FILE_NODE.birthtimeMs = 17e11;
 var defaultDateNow = Date.now;
 var fastWriteCachedNow = Date.now();
-var lastFastMapMiss = {
-  map: void 0,
-  key: "",
-  slot: -1
-};
 var FastDirectoryEntriesMap = class {
+  // Keep speculative slots local so a failed write cannot pin a tenant globally.
+  _missKey = "";
+  _missSlot = -1;
   _table = new Int16Array(128).fill(-1);
   _mask = 127;
   _keys = new Array(64).fill("");
@@ -58722,9 +58738,8 @@ var FastDirectoryEntriesMap = class {
   getForWriteWithHash(k, h) {
     let slot = h & this._mask;
     if (this.size === 0) {
-      lastFastMapMiss.map = this;
-      lastFastMapMiss.key = k;
-      lastFastMapMiss.slot = slot;
+      this._missKey = k;
+      this._missSlot = slot;
       return void 0;
     }
     const mask = this._mask;
@@ -58734,9 +58749,8 @@ var FastDirectoryEntriesMap = class {
     while (true) {
       const idx = table[slot];
       if (idx === -1) {
-        lastFastMapMiss.map = this;
-        lastFastMapMiss.key = k;
-        lastFastMapMiss.slot = firstDeleted !== -1 ? firstDeleted : slot;
+        this._missKey = k;
+        this._missSlot = firstDeleted !== -1 ? firstDeleted : slot;
         return void 0;
       }
       if (idx === -2) {
@@ -58785,6 +58799,7 @@ var FastDirectoryEntriesMap = class {
     return this.get(k) !== void 0;
   }
   _rebuild(newCap) {
+    this._missKey = "";
     const newTableLen = newCap * 2;
     const newMask = newTableLen - 1;
     const newTable = newCap <= 16384 ? new Int16Array(newTableLen).fill(-1) : new Int32Array(newTableLen).fill(-1);
@@ -58824,15 +58839,16 @@ var FastDirectoryEntriesMap = class {
     this._next = writeIdx;
   }
   set(k, v) {
-    if (this === lastFastMapMiss.map && k === lastFastMapMiss.key && this._next < this._keys.length) {
+    if (k === this._missKey && this._next < this._keys.length) {
       const entryIdx = this._next++;
-      this._table[lastFastMapMiss.slot] = entryIdx;
+      this._table[this._missSlot] = entryIdx;
       this._keys[entryIdx] = k;
       this._vals[entryIdx] = v;
       this.size++;
-      lastFastMapMiss.map = void 0;
+      this._missKey = "";
       return this;
     }
+    this._missKey = "";
     if (this._next >= this._keys.length) {
       this._rebuild(this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2);
     }
@@ -58863,6 +58879,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   delete(k) {
+    this._missKey = "";
     if (this.size === 0)
       return false;
     let slot = this._hash(k);
@@ -58888,6 +58905,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   clear() {
+    this._missKey = "";
     if (this._next > 0) {
       this._table.fill(-1);
       for (let i = 0; i < this._next; i++) {
@@ -59340,7 +59358,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const owner = ownedStores.get(this);
     if (path !== "")
       this.validatePath(path, "realpath");
-    return resolveMissingTarget(owner.root, path || ".", options.signal);
+    return resolveMissingTarget(owner.root, path || ".", options.signal, this.ledger.limits);
   }
   async confineExtraction(roots, options = {}) {
     options.signal?.throwIfAborted();
@@ -59593,6 +59611,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
       this.fail("EINVAL", syscall, path);
     if (path.length === 0)
       this.fail("ENOENT", syscall, path);
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
   }
   permission(node, mask, syscall, path) {
     if ((node.mode >> 6 & mask) !== mask)
@@ -59614,6 +59634,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     node.mtimeMs = node.ctimeMs = now;
   }
   resolveNode(path, syscall, followFinal = true) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     if (this.symlinkCount === 0 && isCleanAbsolutePath(path)) {
       const fastDir = cache.lastFastDirNode;
@@ -59698,7 +59720,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         start = slash + 1;
       }
     }
-    let remainingPathUnits = 65536 - path.length;
+    let remainingPathUnits = this.ledger.limits.maxPathBytes - pathByteLength(path);
     if (remainingPathUnits < 0)
       this.fail("ENAMETOOLONG", syscall, path);
     let initialComponents = 0;
@@ -59708,12 +59730,12 @@ var MemoryFileSystem = class _MemoryFileSystem {
         inComp = false;
       else if (!inComp) {
         inComp = true;
-        if (++initialComponents > 256)
+        if (++initialComponents > this.ledger.limits.maxPathComponents)
           this.fail("ENAMETOOLONG", syscall, path);
       }
     }
-    const pending = path.split("/").filter(Boolean);
-    let remainingComponents = 256 - pending.length;
+    let pending = path.split("/").filter(Boolean);
+    let remainingComponents = this.ledger.limits.maxPathComponents - pending.length;
     if (path.endsWith("/"))
       pending.push("");
     const stack = [{ node: this.root, name: "" }];
@@ -59763,9 +59785,9 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (node.type === "symlink" && (options.followFinal !== false || pending.length > 0)) {
         if (++links > 40)
           this.fail("ELOOP", syscall, path);
-        if (node.target.length > remainingPathUnits)
+        if (pathByteLength(node.target) > remainingPathUnits)
           this.fail("ENAMETOOLONG", syscall, path);
-        remainingPathUnits -= node.target.length;
+        remainingPathUnits -= pathByteLength(node.target);
         const target = node.target.split("/").filter(Boolean);
         if (target.length > remainingComponents)
           this.fail("ENAMETOOLONG", syscall, path);
@@ -59774,7 +59796,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           target.push("");
         if (options.resizeCreate !== void 0 && target.at(-1) === "" && pending[0] === "")
           target.pop();
-        pending.unshift(...target);
+        pending = target.concat(pending);
         if (node.target.startsWith("/"))
           stack.splice(1);
         continue;
@@ -59790,6 +59812,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     };
   }
   file(path, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     if (this.symlinkCount === 0 && path.charCodeAt(0) === 47 && path.length > 1 && path.indexOf("/", 1) === -1 && !path.includes("\0")) {
       const name = path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1));
       if (name !== "." && name !== "..") {
@@ -60064,6 +60088,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }, syscall, path);
   }
   writeData(path, data, options, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     if (!(data instanceof Uint8Array))
       throw new TypeError("Memory files require Uint8Array data");
     const target = this.prepareWrite(path, options, syscall);
@@ -60180,9 +60206,11 @@ var MemoryFileSystem = class _MemoryFileSystem {
     this.changed(node, now);
   }
   writeMemoryFileFast(path, data, append, mode) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     const syscall = append ? "appendFile" : "writeFile";
-    if (append && path === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+    if (append && path === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
       const current2 = cache.lastFastFileNode;
       const length2 = current2.byteLength + data.byteLength;
       this.admitSize(current2, length2, syscall, path);
@@ -60196,7 +60224,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     let name = "";
     const cachedPrefix = cache.lastFastDirPrefix;
     const cachedDir = cache.lastFastDirNode;
-    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && cachedPrefix.length > 1 && path.startsWith(cachedPrefix) && path.indexOf("/", cachedPrefix.length) === -1) {
+    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && cachedPrefix.length > 1 && path.startsWith(cachedPrefix) && path.indexOf("/", cachedPrefix.length) === -1) {
       parent = cachedDir;
       name = path.slice(cachedPrefix.length);
       if (exceedsComponentByteLimit2(name))
@@ -60209,7 +60237,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           name = path.slice(start);
           if (exceedsComponentByteLimit2(name))
             this.fail("ENAMETOOLONG", syscall, path);
-          if (start > 1 && (parent.mode & 1) !== 0) {
+          if (start > 1 && (parent.mode & 64) !== 0) {
             cache.lastFastDirPrefix = path.slice(0, start);
             cache.lastFastDirNode = parent;
           }
@@ -60329,6 +60357,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         let ino = this.nextInode;
         this.nextInode = ino + batchCount;
         let nextIdx = 1;
+        entries2._missKey = "";
         entries2._next = 1 + batchCount;
         entries2.size = 1 + batchCount;
         const table = entries2._table;
@@ -60378,6 +60407,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
   }
   writeMemoryFileInDirFast(dirPrefix, name, data, append, mode, nameHash) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(dirPrefix + name, this.ledger.limits);
     const cache = this._cache;
     if (!append && dirPrefix === cache.lastFastDirPrefix && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 192) === 192 && name.length <= 85 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === void 0 && sharedFileNodePoolLen > 0) {
       const parent = cache.lastFastDirNode;
@@ -60405,12 +60436,11 @@ var MemoryFileSystem = class _MemoryFileSystem {
         node.allocation = DUMMY_POOL_ALLOCATION;
         node.sourceRef = node.data.subarray(0);
         const entryIdx = entries2._next++;
-        entries2._table[lastFastMapMiss.slot] = entryIdx;
+        entries2._table[entries2._missSlot] = entryIdx;
         entries2._keys[entryIdx] = name;
         entries2._vals[entryIdx] = node;
         entries2.size++;
-        lastFastMapMiss.map = void 0;
-        lastFastMapMiss.key = "";
+        entries2._missKey = "";
         this.ledger.reserve(name.length * 2, 2, "writeFile", name);
         this.totalBytes += length;
         this.mutationTick = this.mutationTick + 1 | 0;
@@ -60424,7 +60454,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
     const syscall = append ? "appendFile" : "writeFile";
     try {
-      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
         const current2 = cache.lastFastFileNode;
         const length2 = current2.byteLength + data.byteLength;
         this.admitSize(current2, length2, syscall, name);
@@ -60435,7 +60465,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       }
       let parent = this.root;
       const cachedDir = cache.lastFastDirNode;
-      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
+      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
         parent = cachedDir;
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
@@ -60460,7 +60490,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         this.permission(parent, 1, syscall, name);
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
-        if (dirPrefix.length > 1 && (parent.mode & 1) !== 0) {
+        if (dirPrefix.length > 1 && (parent.mode & 64) !== 0) {
           cache.lastFastDirPrefix = dirPrefix;
           cache.lastFastDirNode = parent;
         }
@@ -60536,11 +60566,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
             cache.lastFastFilePath = "";
             cache.lastFastFileName = name;
             cache.lastFastFileNode = node;
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
           } catch (error) {
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
             this.ledger.release(nameBytes, 2);
             throw error;
           }
@@ -62534,27 +62560,42 @@ function* parseXmlSteps(input, limits = {}) {
       throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
   };
   let pendingWork = 0;
-  const skipWhitespace = () => {
+  const skipWhitespace = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     return offset - start2;
   };
-  const scanName = () => {
+  const scanName = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c === 32 || c === 9 || c === 13 || c === 10 || c === 47 || c === 61 || c === 62 || c === 63)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     const name = source.slice(start2, offset);
+    pendingWork += offset - start2;
+    while (pendingWork >= 512) {
+      yield 512;
+      pendingWork -= 512;
+    }
     const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
-    return [name, prefix, localName, (offset - start2) * 2];
+    return [name, prefix, localName];
   };
   while (offset < source.length) {
     pendingWork += 1;
@@ -62591,11 +62632,15 @@ function* parseXmlSteps(input, limits = {}) {
         }
       } else {
         for (let index = 0; index < resolved.length; index++) {
+          pendingWork++;
+          if (pendingWork >= 512) {
+            yield 512;
+            pendingWork -= 512;
+          }
           const c = resolved.charCodeAt(index);
           if (c !== 32 && c !== 9 && c !== 13 && c !== 10)
             invalid("text outside the root");
         }
-        pendingWork += resolved.length;
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -62637,8 +62682,7 @@ function* parseXmlSteps(input, limits = {}) {
     } else if (source.startsWith("<?", offset)) {
       const start2 = offset;
       offset += 2;
-      const [target, , , wName] = scanName();
-      pendingWork += wName;
+      const [target] = yield* scanName();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -62677,8 +62721,8 @@ function* parseXmlSteps(input, limits = {}) {
       invalid("DTD and entity declarations are forbidden");
     } else if (source.charCodeAt(offset + 1) === 47) {
       offset += 2;
-      const [name, , , wName] = scanName();
-      pendingWork += wName + skipWhitespace();
+      const [name] = yield* scanName();
+      yield* skipWhitespace();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -62691,10 +62735,11 @@ function* parseXmlSteps(input, limits = {}) {
     } else {
       offset++;
       const repeated = previousEmpty && source.startsWith(previousEmpty.suffix, offset) ? previousEmpty : void 0;
-      const [name, prefix, localName, wName] = repeated ? [repeated.name, repeated.prefix, repeated.localName, repeated.name.length * 2] : scanName();
+      const [name, prefix, localName] = repeated ? [repeated.name, repeated.prefix, repeated.localName] : yield* scanName();
       if (repeated)
         offset += name.length;
-      pendingWork += wName;
+      if (repeated)
+        pendingWork += name.length * 2;
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -62704,8 +62749,7 @@ function* parseXmlSteps(input, limits = {}) {
       let namespaces = stack.at(-1)?.namespaces ?? /* @__PURE__ */ new Map([["xml", xmlNamespace]]);
       let ownsNamespaces = stack.length === 0;
       while (!repeated) {
-        const ws = skipWhitespace();
-        pendingWork += ws;
+        const ws = yield* skipWhitespace();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -62715,8 +62759,7 @@ function* parseXmlSteps(input, limits = {}) {
           break;
         if (ws === 0)
           invalid("attributes require whitespace");
-        const [attribute, attrPrefix, attrLocal, wAttr] = scanName();
-        pendingWork += wAttr;
+        const [attribute, attrPrefix, attrLocal] = yield* scanName();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -62727,10 +62770,10 @@ function* parseXmlSteps(input, limits = {}) {
           throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
         if ((attributes?.size ?? 0) >= maxAttributesPerElement)
           throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         if (source[offset++] !== "=")
           invalid("missing attribute equals");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         const quote = source[offset++];
         if (quote !== '"' && quote !== "'")
           invalid("unquoted attribute");
@@ -62917,14 +62960,13 @@ function scalar(element) {
 
 // ../safe-fs/dist/fs/webdav/webdav.js
 var timestampNamespace = "urn:virtual-bash:metadata";
-var maxTimestampPropertyBytes = 4096;
-function preflightTimestamps(property) {
+function preflightTimestamps(property, maxTimestampPropertyBytes) {
   let bytes = 0;
   for (const point of property.text) {
     const code = point.codePointAt(0);
     bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
     if (bytes > maxTimestampPropertyBytes)
-      throw new Error("timestamp property exceeds 4KiB limit");
+      throw new Error("timestamp property exceeds byte limit");
   }
   const text = scalar(property);
   let offset = 0;
@@ -63165,6 +63207,7 @@ var WebDavFileSystem = class {
   headers;
   maxResponseBytes;
   maxXmlBytes;
+  maxTimestampPropertyBytes;
   maxEntries;
   xmlLimits;
   timeoutMs;
@@ -63234,6 +63277,7 @@ var WebDavFileSystem = class {
       streamingAppend: this.requestStreamSupport !== false
     });
     this.maxResponseBytes = options.maxResponseBytes === void 0 ? Infinity : positive(options.maxResponseBytes, "maxResponseBytes", false, true);
+    this.maxTimestampPropertyBytes = positive(options.maxTimestampPropertyBytes ?? Infinity, "maxTimestampPropertyBytes", true, true);
     this.maxXmlBytes = options.maxXmlBytes === void 0 ? Infinity : positive(options.maxXmlBytes, "maxXmlBytes", false, true);
     this.xmlLimits = Object.freeze({ ...options.xmlLimits });
     for (const [name, value] of Object.entries(this.xmlLimits))
@@ -63669,7 +63713,7 @@ var WebDavFileSystem = class {
     let mtimeMs = date("getlastmodified") ?? 0;
     let atimeMs = 0;
     if (timestampProperty) {
-      const timestamps = JSON.parse(preflightTimestamps(timestampProperty));
+      const timestamps = JSON.parse(preflightTimestamps(timestampProperty, this.maxTimestampPropertyBytes));
       if (typeof timestamps !== "object" || timestamps === null || !("version" in timestamps) || timestamps.version !== 1 || !("etag" in timestamps) || typeof timestamps.etag !== "string" || !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(timestamps.etag) || !("type" in timestamps) || timestamps.type !== "file" && timestamps.type !== "directory" || !("atimeMs" in timestamps) || typeof timestamps.atimeMs !== "number" || !Number.isFinite(timestamps.atimeMs) || Math.abs(timestamps.atimeMs) > 864e13 || !("mtimeMs" in timestamps) || typeof timestamps.mtimeMs !== "number" || !Number.isFinite(timestamps.mtimeMs) || Math.abs(timestamps.mtimeMs) > 864e13)
         throw new Error("invalid timestamp property");
       if (timestamps.etag === validator && timestamps.type === (directory ? "directory" : "file")) {