@poe-platform/safe-bash 0.1.630 → 0.1.632

package/dist/safe-bash/chunks/{chunk-3BZ5NQ73.js → chunk-WECHUK3Y.js}

@@ -2,21 +2,23 @@ import {
   UsageError,
   pathOf,
   writeDiagnostic
-} from "./chunk-GFZKQIPL.js";
+} from "./chunk-LA6BX562.js";
 import {
   PublicDiagnostic,
-  publicDiagnosticMessage,
+  publicDiagnosticMessage
+} from "./chunk-3E5M2WEL.js";
+import {
   yieldTurn
-} from "./chunk-UYX72YHY.js";
+} from "./chunk-THXJ6CLF.js";
 import {
   readBytes,
   toByteSource,
   writeBytes
-} from "./chunk-CXMIIXJA.js";
+} from "./chunk-WPIOO4NX.js";
 import {
   import_buffer,
   init_platform
-} from "./chunk-2KL6W6NB.js";
+} from "./chunk-O2EVBRKF.js";
 
 // packages/safe-bash/src/commands/node/browser.ts
 init_platform();
@@ -97,7 +99,7 @@ init_platform();
 // packages/safe-js/dist/browser/safe-fs.js
 init_platform();
 
-// packages/safe-js/dist/browser/chunks/chunk-SB2GDI2R.js
+// packages/safe-js/dist/browser/chunks/chunk-RILLSV3Z.js
 init_platform();
 var platform = Object.freeze({
   errno(_code) {
@@ -162,7 +164,7 @@ var descriptions = {
   EPERM: "operation not permitted",
   EPIPE: "broken pipe",
   EROFS: "read-only file system",
-  ESPIPE: "invalid seek",
+  ESPIPE: "illegal seek",
   ETIMEDOUT: "operation timed out",
   EXDEV: "cross-device link not permitted"
 };
@@ -254,6 +256,193 @@ async function* readBytes2(source, signal) {
     }
   }
 }
+function admitCapabilities(path, options, capabilities) {
+  if (![capabilities.positionedRead, capabilities.positionedWrite, capabilities.truncate].every((value) => typeof value === "boolean") || capabilities.position !== void 0 && typeof capabilities.position !== "boolean" || capabilities.readObservation !== void 0 && typeof capabilities.readObservation !== "boolean" || capabilities.openTruncate !== void 0 && typeof capabilities.openTruncate !== "boolean" || capabilities.positionedAppendWrite !== void 0 && typeof capabilities.positionedAppendWrite !== "boolean" || capabilities.delegateZeroLengthWrite !== void 0 && typeof capabilities.delegateZeroLengthWrite !== "boolean" || !["none", "volatile", "storage"].includes(capabilities.synchronization)) throw new FsError("EINVAL", { syscall: "open", path });
+  if (options.truncate && !(capabilities.openTruncate ?? capabilities.truncate) || options.synchronization !== void 0 && capabilities.synchronization === "none") {
+    throw new FsError("ENOTSUP", { syscall: "open", path });
+  }
+}
+function integer(value, syscall, path) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new FsError("EINVAL", { syscall, path });
+}
+var ManagedFileDescriptor = class {
+  capabilities;
+  #path;
+  #access;
+  #append;
+  #getPosition;
+  #probeRead;
+  #backend;
+  #pending = Promise.resolve();
+  #closing;
+  constructor(path, options, capabilities, backend) {
+    this.#path = path;
+    this.#access = options.access;
+    this.#append = options.append;
+    const getPosition = capabilities.position === true ? backend.getPosition : void 0;
+    if (capabilities.position === true && typeof getPosition !== "function") throw new FsError("ENOTSUP", { syscall: "getPosition", path });
+    this.#getPosition = getPosition?.bind(backend);
+    const probeRead = capabilities.readObservation === true ? backend.probeRead : void 0;
+    if (capabilities.readObservation === true && typeof probeRead !== "function") throw new FsError("ENOTSUP", { syscall: "probeRead", path });
+    this.#probeRead = probeRead?.bind(backend);
+    this.#backend = backend;
+    const positionedAppendWrite = capabilities.positionedAppendWrite === true && capabilities.positionedWrite && options.access !== "read";
+    this.capabilities = Object.freeze({
+      ...capabilities.position === void 0 ? {} : { position: capabilities.position },
+      ...capabilities.readObservation === void 0 ? {} : { readObservation: capabilities.readObservation },
+      ...capabilities.openTruncate === void 0 ? {} : { openTruncate: capabilities.openTruncate },
+      positionedRead: capabilities.positionedRead && options.access !== "write",
+      positionedWrite: capabilities.positionedWrite && options.access !== "read" && (!options.append || positionedAppendWrite),
+      ...capabilities.positionedAppendWrite === void 0 ? {} : { positionedAppendWrite },
+      ...capabilities.delegateZeroLengthWrite === void 0 ? {} : { delegateZeroLengthWrite: capabilities.delegateZeroLengthWrite && options.access !== "read" },
+      truncate: capabilities.truncate && options.access !== "read",
+      synchronization: capabilities.synchronization
+    });
+  }
+  #run(syscall, options, action) {
+    const signal = options.signal;
+    try {
+      signal?.throwIfAborted();
+      if (this.#closing || !this.#backend) throw new FsError("EBADF", { syscall, path: this.#path });
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const forwarded = signal === void 0 ? {} : { signal };
+    const operation = this.#pending.then(async () => {
+      signal?.throwIfAborted();
+      try {
+        const result = await action(this.#backend, forwarded);
+        signal?.throwIfAborted();
+        return result;
+      } catch (error) {
+        signal?.throwIfAborted();
+        throw error;
+      }
+    });
+    this.#pending = operation.then(() => {
+    }, () => {
+    });
+    return operation;
+  }
+  #position(buffer, position, syscall) {
+    if (!(buffer instanceof Uint8Array)) throw new FsError("EINVAL", { syscall, path: this.#path });
+    if (position !== null) {
+      integer(position, syscall, this.#path);
+      if (syscall === "write" && this.#append && this.capabilities.positionedAppendWrite !== true) throw new FsError("EINVAL", { syscall, path: this.#path });
+      if (!(syscall === "read" ? this.capabilities.positionedRead : this.capabilities.positionedWrite)) {
+        throw new FsError("ESPIPE", { syscall, path: this.#path });
+      }
+    }
+  }
+  stat(options = {}) {
+    return this.#run("fstat", options, (backend, forwarded) => backend.stat(backend.resource, forwarded));
+  }
+  getPosition(options = {}) {
+    return this.#run("getPosition", options, async (backend, forwarded) => {
+      if (!this.capabilities.position || !this.#getPosition) throw new FsError("ENOTSUP", { syscall: "getPosition", path: this.#path });
+      const position = await this.#getPosition(backend.resource, forwarded);
+      if (!Number.isSafeInteger(position) || position < 0) throw new FsError("EIO", { syscall: "getPosition", path: this.#path });
+      return position;
+    });
+  }
+  probeRead(options = {}) {
+    return this.#run("probeRead", options, async (backend, forwarded) => {
+      if (!this.capabilities.readObservation || !this.#probeRead) throw new FsError("ENOTSUP", { syscall: "probeRead", path: this.#path });
+      const readiness = await this.#probeRead(backend.resource, forwarded);
+      if (readiness !== "ready" && readiness !== "blocked" && readiness !== "unknown") throw new FsError("EIO", { syscall: "probeRead", path: this.#path });
+      return readiness;
+    });
+  }
+  read(buffer, position, options = {}) {
+    return this.#run("read", options, async (backend, forwarded) => {
+      if (this.#access === "write") throw new FsError("EBADF", { syscall: "read", path: this.#path });
+      this.#position(buffer, position, "read");
+      if (buffer.byteLength === 0) return 0;
+      const count = await backend.read(backend.resource, buffer, position, forwarded);
+      if (!Number.isSafeInteger(count) || count < 0 || count > buffer.byteLength) throw new FsError("EIO", { syscall: "read", path: this.#path });
+      return count;
+    });
+  }
+  write(buffer, position, options = {}) {
+    return this.#run("write", options, async (backend, forwarded) => {
+      if (this.#access === "read") throw new FsError("EBADF", { syscall: "write", path: this.#path });
+      this.#position(buffer, position, "write");
+      if (buffer.byteLength === 0 && this.capabilities.delegateZeroLengthWrite !== true) return 0;
+      const count = await backend.write(backend.resource, buffer, position, forwarded);
+      if (!Number.isSafeInteger(count) || count < 0 || count > buffer.byteLength) throw new FsError("EIO", { syscall: "write", path: this.#path });
+      return count;
+    });
+  }
+  truncate(length, options = {}) {
+    return this.#run("ftruncate", options, async (backend, forwarded) => {
+      if (this.#access === "read") throw new FsError("EBADF", { syscall: "ftruncate", path: this.#path });
+      integer(length, "ftruncate", this.#path);
+      if (!this.capabilities.truncate) throw new FsError("ENOTSUP", { syscall: "ftruncate", path: this.#path });
+      await backend.truncate(backend.resource, length, forwarded);
+    });
+  }
+  sync(dataOnly, options = {}) {
+    return this.#run(dataOnly ? "fdatasync" : "fsync", options, async (backend, forwarded) => {
+      if (typeof dataOnly !== "boolean") throw new FsError("EINVAL", { syscall: "fsync", path: this.#path });
+      if (this.capabilities.synchronization === "none") throw new FsError("ENOTSUP", { syscall: dataOnly ? "fdatasync" : "fsync", path: this.#path });
+      await backend.sync(backend.resource, dataOnly, forwarded);
+    });
+  }
+  close() {
+    this.#closing ??= this.#pending.then(async () => {
+      try {
+        await this.#backend.close(this.#backend.resource);
+      } finally {
+        this.#backend = void 0;
+        this.#getPosition = void 0;
+        this.#probeRead = void 0;
+        this.#pending = Promise.resolve();
+      }
+    });
+    return this.#closing;
+  }
+};
+async function openFileDescriptor(path, options, capabilities, acquire) {
+  if (!options || typeof options !== "object") throw new FsError("EINVAL", { syscall: "open", path });
+  const signal = options.signal;
+  signal?.throwIfAborted();
+  const keys = ["access", "creation", "truncate", "append", "mode", "synchronization", "signal"];
+  const { access, creation = "never", truncate = false, append = false, mode: mode2 = 438, synchronization } = options;
+  if (Object.keys(options).some((key) => !keys.includes(key)) || !["read", "write", "readwrite"].includes(access) || !["never", "ifMissing", "exclusive"].includes(creation) || typeof truncate !== "boolean" || typeof append !== "boolean" || access === "read" && (truncate || append) || synchronization !== void 0 && !["data", "all"].includes(synchronization) || !Number.isSafeInteger(mode2) || mode2 < 0 || mode2 > 4095) {
+    throw new FsError("EINVAL", { syscall: "open", path });
+  }
+  const admitted = Object.freeze({
+    access,
+    creation,
+    truncate,
+    append,
+    mode: mode2,
+    ...signal === void 0 ? {} : { signal },
+    ...synchronization === void 0 ? {} : { synchronization }
+  });
+  const admittedCapabilities = Object.freeze({ ...capabilities });
+  admitCapabilities(path, admitted, admittedCapabilities);
+  let backend;
+  try {
+    backend = await acquire(admitted);
+  } catch (error) {
+    signal?.throwIfAborted();
+    throw error;
+  }
+  try {
+    signal?.throwIfAborted();
+    const selected = Object.freeze({ ...backend.capabilities ?? admittedCapabilities });
+    signal?.throwIfAborted();
+    admitCapabilities(path, admitted, selected);
+    const descriptor = new ManagedFileDescriptor(path, admitted, selected, backend);
+    signal?.throwIfAborted();
+    return descriptor;
+  } catch (error) {
+    await finishCleanup(() => backend.close(backend.resource), true);
+    signal?.throwIfAborted();
+    throw error;
+  }
+}
 function dirname(path) {
   if (typeof path !== "string") throw new TypeError("path must be a string");
   let end = path.length;
@@ -689,8 +878,14 @@ var defaultMemoryFileSystemLimits = Object.freeze({
 });
 function normalizeMemoryFileSystemLimits(options) {
   const keys = ["maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
-  const record2 = readConfigRecord(options, "memory option", keys);
+  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) {
     const value = Object.hasOwn(record2, key) ? record2[key] : limits[key];
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (key === "maxMetadataUnits" ? 1 : 0)) {
@@ -701,6 +896,7 @@ function normalizeMemoryFileSystemLimits(options) {
   return Object.freeze(limits);
 }
 var typeModes = { file: 32768, directory: 16384, symlink: 40960 };
+var preferredIoBlockSize = 64 * 1024;
 var ext4HtreeEof64 = (1n << 63n) - 1n;
 var ownedStats = /* @__PURE__ */ new WeakMap();
 var ownedStores = /* @__PURE__ */ new WeakMap();
@@ -746,6 +942,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       readdir: true,
       realpath: true,
       access: true,
+      open: true,
       write: true,
       append: true,
       exclusiveCreate: true,
@@ -772,6 +969,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       atomicRename: true,
       atomicFileStaging: true,
       atomicFileMutation: true,
+      atomicEntryRemoval: true,
       atomicDirectoryMetadata: true,
       streamingRead: true,
       retainedRead: true,
@@ -788,6 +986,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
   nextInode = 1;
   ledger;
   root;
+  totalBytes = 0;
   constructor(options = {}) {
     this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
     this.ledger.reserve(0, 1, "mkdir", "/");
@@ -840,7 +1039,9 @@ var MemoryFileSystem = class _MemoryFileSystem {
     this.ledger.reserve(bytes, 2, syscall, path);
     try {
       const node = create();
+      if (node.type === "file") this.admitSize(void 0, node.data.byteLength, syscall, path);
       parent.entries.set(name, node);
+      if (node.type === "file") this.totalBytes += node.data.byteLength;
       this.changed(parent);
       return node;
     } catch (error) {
@@ -851,7 +1052,10 @@ var MemoryFileSystem = class _MemoryFileSystem {
   releaseNode(node) {
     if (node.nlink !== 0 || node.references !== 0) return;
     this.ledger.release(node.type === "symlink" ? node.target.length * 2 : 0, 1);
-    if (node.type === "file") node.allocation.release();
+    if (node.type === "file") {
+      this.totalBytes -= node.data.byteLength;
+      node.allocation.release();
+    }
   }
   releaseReference(node, path) {
     node.references--;
@@ -860,10 +1064,17 @@ var MemoryFileSystem = class _MemoryFileSystem {
   }
   replaceData(node, allocation, length = allocation.data.byteLength) {
     const previous = node.allocation;
+    this.totalBytes += length - node.data.byteLength;
     node.data = allocation.data.subarray(0, length);
     node.allocation = allocation;
     previous.release();
   }
+  admitSize(node, length, syscall, path) {
+    this.ledger.fileSize(length, syscall, path);
+    if (length - (node?.data.byteLength ?? 0) > (this.ledger.limits.maxBytes ?? Number.MAX_SAFE_INTEGER) - this.totalBytes) {
+      this.fail("ENOSPC", syscall, path);
+    }
+  }
   fail(code, syscall, path, dest) {
     throw new FsError(code, { syscall, path, ...dest === void 0 ? {} : { dest } });
   }
@@ -952,6 +1163,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
   snapshot(node) {
     return {
       type: node.type,
+      ioBlockSize: preferredIoBlockSize,
       ...Number.isSafeInteger(node.revision) ? { revision: node.revision } : {},
       preferredIoBlockSize: 4096,
       size: node.type === "file" ? node.data.byteLength : node.type === "symlink" ? new TextEncoder().encode(node.target).byteLength : 0,
@@ -988,6 +1200,71 @@ var MemoryFileSystem = class _MemoryFileSystem {
       throw new FsError("EFBIG", { syscall, path, cause });
     }
   }
+  open(path, options) {
+    return openFileDescriptor(path, options, {
+      positionedRead: true,
+      positionedWrite: true,
+      truncate: true,
+      synchronization: "volatile",
+      position: true
+    }, async (admitted) => {
+      const location = this.resolve(path, "open", {
+        followFinal: admitted.creation !== "exclusive",
+        allowMissing: admitted.creation !== "never"
+      });
+      let node = location.node;
+      if (node) {
+        if (admitted.creation === "exclusive") this.fail("EEXIST", "open", path);
+        if (node.type !== "file") this.fail("EISDIR", "open", path);
+        this.permission(node, admitted.access === "read" ? 4 : admitted.access === "write" ? 2 : 6, "open", path);
+      } else {
+        this.permission(location.parent, 3, "open", path);
+      }
+      this.ledger.reserve(path.length * 2, 1, "open", path);
+      try {
+        node ??= this.openWrite(path, {}, "open", { location, mode: admitted.mode, append: false });
+        if (admitted.truncate) this.resizeNode(node, 0, "open", path);
+      } catch (error) {
+        this.ledger.release(path.length * 2, 1);
+        throw error;
+      }
+      node.references++;
+      const resource = { node, position: 0 };
+      return {
+        resource,
+        getPosition: async (retained) => retained.position,
+        stat: async (retained) => this.snapshot(retained.node),
+        read: async (retained, buffer, position) => {
+          const inode = retained.node;
+          const start = position ?? retained.position;
+          const count = Math.min(buffer.byteLength, Math.max(0, inode.data.byteLength - start));
+          buffer.set(inode.data.subarray(start, start + count));
+          if (position === null) retained.position += count;
+          inode.atimeMs = Date.now();
+          return count;
+        },
+        write: async (retained, buffer, position) => {
+          const inode = retained.node;
+          const start = admitted.append ? inode.data.byteLength : position ?? retained.position;
+          const end = start + buffer.byteLength;
+          this.writeAt(inode, buffer, start, "write", path);
+          if (position === null) retained.position = end;
+          return buffer.byteLength;
+        },
+        truncate: async (retained, length) => {
+          const inode = retained.node;
+          this.resizeNode(inode, length, "ftruncate", path);
+        },
+        sync: async () => {
+        },
+        close: async (retained) => {
+          const inode = retained.node;
+          retained.node = void 0;
+          this.releaseReference(inode, path);
+        }
+      };
+    });
+  }
   prepareWrite(path, options, syscall) {
     const flag = options.flag ?? "w";
     if (!["w", "wx", "a", "ax"].includes(flag)) this.fail("EINVAL", syscall, path);
@@ -1016,7 +1293,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const target = this.prepareWrite(path, options, syscall);
     const current = target.location.node;
     const length = (target.append ? current?.data.byteLength ?? 0 : 0) + data.byteLength;
-    this.ledger.fileSize(length, syscall, path);
+    this.admitSize(current, length, syscall, path);
     const growth = target.append && length > (current?.allocation.data.byteLength ?? 0) ? length : 0;
     this.ledger.check(data.byteLength + growth + (current ? 0 : target.location.name.length * 2), current ? 0 : 2, syscall, path);
     const copied = this.bytes(data, syscall, path);
@@ -1062,6 +1339,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const end = position + data.byteLength;
     this.ledger.fileSize(end, syscall, path);
     const length = Math.max(node.data.byteLength, end);
+    this.admitSize(node, length, syscall, path);
     let allocation = node.allocation;
     if (length > allocation.data.byteLength) {
       this.ledger.check(length, 0, syscall, path);
@@ -1082,7 +1360,10 @@ var MemoryFileSystem = class _MemoryFileSystem {
       throw error;
     }
     if (allocation !== node.allocation) this.replaceData(node, allocation, length);
-    else node.data = allocation.data.subarray(0, length);
+    else {
+      this.totalBytes += length - node.data.byteLength;
+      node.data = allocation.data.subarray(0, length);
+    }
     this.changed(node);
   }
   async readFile(path, options = {}) {
@@ -1129,6 +1410,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const mode2 = this.mode(options.mode, content.type === "file" ? 438 : 511, "createStagedFile", directoryPath);
     for (const time of [options.atimeMs, options.mtimeMs]) if (time !== void 0 && !Number.isFinite(time)) this.fail("EINVAL", "createStagedFile", directoryPath);
     if (content.type === "file" && !(content.data instanceof Uint8Array)) throw new TypeError("Staged files require Uint8Array data");
+    if (content.type === "file") this.admitSize(void 0, content.data.byteLength, "createStagedFile", directoryPath);
     if (content.type === "symlink") this.validatePath(content.target, "createStagedFile");
     const retained = (location.name.length + name.length) * 2 + (content.type === "symlink" ? content.target.length * 2 : 0);
     this.ledger.reserve(retained, 4, "createStagedFile", directoryPath);
@@ -1143,6 +1425,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (options.mtimeMs !== void 0) file.mtimeMs = options.mtimeMs;
       directory.entries.set(name, file);
       location.parent.entries.set(location.name, directory);
+      if (file.type === "file") this.totalBytes += file.data.byteLength;
     } catch (error) {
       allocation?.release();
       this.ledger.release(retained, 4);
@@ -1217,6 +1500,25 @@ var MemoryFileSystem = class _MemoryFileSystem {
     this.writeData(path, data, { ...options.mode === void 0 ? {} : { mode: options.mode }, flag: options.append ? "a" : "w" }, "writeFileConditional");
     return Object.freeze(this.snapshot(location.parent.entries.get(location.name)));
   }
+  async removeEntryConditional(path, options) {
+    options.signal?.throwIfAborted();
+    const location = this.entry(path, "removeEntryConditional", true);
+    this.expectEntry(location.parent, options.parent, path, false);
+    this.expectEntry(location.node, options.expected, path);
+    const node = location.node;
+    if (this.terminalDot(path)) this.fail("EINVAL", "removeEntryConditional", path);
+    if (node === this.root) this.fail("EBUSY", "removeEntryConditional", path);
+    if (node.type !== "file" && node.type !== "symlink" && node.type !== "directory") this.fail("EINVAL", "removeEntryConditional", path);
+    this.permission(location.parent, 3, "removeEntryConditional", path);
+    if (node.type === "directory" && node.entries.size > 0) this.fail("ENOTEMPTY", "removeEntryConditional", path);
+    location.parent.entries.delete(location.name);
+    this.ledger.release(location.name.length * 2, 1);
+    node.nlink--;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    this.releaseNode(node);
+    this.changed(location.parent);
+  }
   async removeFileConditional(path, options) {
     options.signal?.throwIfAborted();
     const location = this.entry(path, "removeFileConditional", true);
@@ -1327,6 +1629,9 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
     this.changed(location.parent);
   }
+  unlink(path, options = {}) {
+    return this.rm(path, { ...options.signal === void 0 ? {} : { signal: options.signal } });
+  }
   async rename(source, destination, options = {}) {
     options.signal?.throwIfAborted();
     try {
@@ -1381,7 +1686,6 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (target.node === origin) this.fail("EINVAL", "copyFile", source, destination);
       const node = this.writeData(destination, origin.data, { mode: origin.mode & 4095, flag: options.exclusive ? "wx" : "w" }, "copyFile");
       node.mode = origin.mode;
-      this.changed(node);
       origin.atimeMs = Date.now();
     } catch (error) {
       if (error instanceof FsError) throw new FsError(error.code, { syscall: "copyFile", path: source, dest: destination, cause: error });
@@ -1459,6 +1763,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     this.resizeNode(node, length, "truncate", path);
   }
   resizeNode(node, length, syscall, path) {
+    this.admitSize(node, length, syscall, path);
     const data = this.allocate(length, syscall, path);
     try {
       data.data.set(node.data.subarray(0, length));
@@ -1491,7 +1796,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       throw error;
     }
     const snapshot = this.snapshot.bind(this);
-    const integer2 = this.integer.bind(this);
+    const integer3 = this.integer.bind(this);
     const resizeNode = this.resizeNode.bind(this);
     const releaseReference = this.releaseReference.bind(this);
     let closing;
@@ -1509,7 +1814,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       },
       async truncate(length, options2 = {}) {
         const file = current(options2.signal, "ftruncate");
-        integer2(length, "ftruncate", path);
+        integer3(length, "ftruncate", path);
         resizeNode(file, length, "ftruncate", path);
       },
       close() {
@@ -1566,7 +1871,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     this.ledger.reserve(path.length * 2, 1, "openReadFile", path);
     node.references++;
     const snapshot = this.snapshot.bind(this);
-    const integer2 = this.integer.bind(this);
+    const integer3 = this.integer.bind(this);
     const releaseReference = this.releaseReference.bind(this);
     let closing;
     const current = (signal2, syscall) => {
@@ -1584,8 +1889,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
       },
       async read(position, maxBytes, options2 = {}) {
         const file = current(options2.signal, "read");
-        integer2(position, "read", path);
-        integer2(maxBytes, "read", path);
+        integer3(position, "read", path);
+        integer3(maxBytes, "read", path);
         if (maxBytes === 0 || maxBytes > Number.MAX_SAFE_INTEGER - position) {
           throw new FsError("EINVAL", { syscall: "read", path });
         }
@@ -1607,7 +1912,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
   async *readStream(path, options = {}) {
     options.signal?.throwIfAborted();
     const start = options.start ?? 0;
-    const chunkSize2 = options.chunkSize ?? 64 * 1024;
+    const chunkSize2 = options.chunkSize ?? preferredIoBlockSize;
     this.integer(start, "readStream", path);
     this.integer(chunkSize2, "readStream", path);
     if (chunkSize2 === 0) this.fail("EINVAL", "readStream", path);
@@ -1688,6 +1993,7 @@ function stockDescriptorWrite(filesystem) {
     "mode",
     "bytes",
     "allocate",
+    "admitSize",
     "changed",
     "metadata",
     "integer",
@@ -1723,6 +2029,7 @@ var deviceCapabilities = Object.freeze({
   retainedRead: true,
   streamingWrite: true,
   streamingAppend: true,
+  independentWriteStreams: true,
   copy: true,
   exclusiveCopy: true,
   remove: false,
@@ -1738,7 +2045,9 @@ var deviceCapabilities = Object.freeze({
   timestamps: false,
   truncate: false,
   randomAccessWrite: false,
+  open: false,
   atomicFileMutation: false,
+  atomicEntryRemoval: false,
   atomicFileStaging: false,
   atomicDirectoryMetadata: false,
   atomicRename: false,
@@ -1894,7 +2203,7 @@ function* validDeclaration(content, expectedEncoding) {
     return offset - start;
   };
   const field = function* (name) {
-    if (content.slice(offset, offset + name.length).toLowerCase() !== name) return void 0;
+    if (content.slice(offset, offset + name.length) !== name) return void 0;
     offset += name.length;
     yield name.length;
     yield* whitespace();
@@ -1913,17 +2222,17 @@ function* validDeclaration(content, expectedEncoding) {
   };
   if (!(yield* whitespace()) || (yield* field("version")) !== "1.0") return false;
   let spacing = yield* whitespace();
-  if (content.slice(offset, offset + 8).toLowerCase() === "encoding") {
+  if (content.slice(offset, offset + 8) === "encoding") {
     if (!spacing) return false;
     const encoding = yield* field("encoding");
     if (encoding === void 0 || encoding.length > 8 || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase())) return false;
-    if (expectedEncoding !== void 0 && encoding.toLowerCase() !== expectedEncoding.toLowerCase()) return false;
+    if (expectedEncoding !== void 0 && encoding.toLowerCase() !== expectedEncoding.toLowerCase() && !(encoding.toLowerCase() === "utf-16" && (expectedEncoding === "UTF-16LE" || expectedEncoding === "UTF-16BE"))) return false;
     spacing = yield* whitespace();
   }
-  if (content.slice(offset, offset + 10).toLowerCase() === "standalone") {
+  if (content.slice(offset, offset + 10) === "standalone") {
     if (!spacing) return false;
     const standalone = yield* field("standalone");
-    if (standalone === void 0 || standalone.length > 3 || !["yes", "no"].includes(standalone.toLowerCase())) return false;
+    if (standalone === void 0 || standalone.length > 3 || !["yes", "no"].includes(standalone)) return false;
     yield* whitespace();
   }
   return offset === content.length;
@@ -1942,6 +2251,13 @@ function* parseXmlSteps(input, limits = {}) {
   for (const limit of [maxDepth, maxNodes, maxAttributes, maxContentNodes, maxAttributesPerElement, maxNamespaces]) {
     if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("XML limits must be positive integers");
   }
+  const maxTextLength = limits.maxTextLength ?? Number.MAX_SAFE_INTEGER;
+  if (!Number.isSafeInteger(maxTextLength) || maxTextLength < 1) throw new RangeError("XML limits must be positive integers");
+  let textLength = 0;
+  const admitText = (text) => {
+    if (text.length > maxTextLength - textLength) throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
+    textLength += text.length;
+  };
   const chunks = [];
   let chunk = "";
   for (let index = input.charCodeAt(0) === 65279 ? 1 : 0; index < input.length; index++) {
@@ -1965,6 +2281,8 @@ function* parseXmlSteps(input, limits = {}) {
   const source = chunks.join("");
   const stack = [];
   let root;
+  const prolog = [];
+  const epilog = [];
   let declaration;
   let offset = 0;
   let nodes = 0;
@@ -1996,6 +2314,7 @@ function* parseXmlSteps(input, limits = {}) {
     return name;
   };
   const appendText = function* (text, kind = "text") {
+    admitText(text);
     const parent = stack.at(-1);
     if (parent) {
       parent.element.text += text;
@@ -2009,6 +2328,10 @@ function* parseXmlSteps(input, limits = {}) {
         if ((index + 1) % 512 === 0) yield 512;
       }
       if (text.length % 512) yield text.length % 512;
+      if (retainContent && text.length) {
+        admitContent();
+        (root ? epilog : prolog).push({ kind, text });
+      }
     }
   };
   while (offset < source.length) {
@@ -2017,7 +2340,7 @@ function* parseXmlSteps(input, limits = {}) {
       const next = yield* find(source, "<", offset);
       const text = source.slice(offset, next < 0 ? source.length : next);
       if ((yield* find(text, "]]>", 0)) >= 0) invalid("CDATA terminator in text");
-      yield* appendText(yield* entities(text));
+      yield* appendText(stack.length ? yield* entities(text) : text);
       offset += text.length;
     } else if (source.startsWith("<!--", offset)) {
       const end = yield* find(source, "-->", offset + 4);
@@ -2025,9 +2348,11 @@ function* parseXmlSteps(input, limits = {}) {
         invalid("malformed comment");
       }
       const parent = stack.at(-1);
-      if (retainContent && parent) {
+      const text = source.slice(offset + 4, end);
+      admitText(text);
+      if (retainContent) {
         admitContent();
-        parent.content.push({ kind: "comment", text: source.slice(offset + 4, end) });
+        (parent?.content ?? (root ? epilog : prolog)).push({ kind: "comment", text });
       }
       offset = end + 3;
     } else if (source.startsWith("<![CDATA[", offset)) {
@@ -2051,15 +2376,17 @@ function* parseXmlSteps(input, limits = {}) {
       } else if (content && !" 	\n\r".includes(content[0])) invalid("invalid processing instruction");
       if (!(target.length === 3 && target.toLowerCase() === "xml")) {
         const parent = stack.at(-1);
-        if (retainContent && parent) {
-          let start2 = 0;
-          while (start2 < content.length && " 	\n\r".includes(content[start2])) {
-            start2++;
-            if (start2 % 512 === 0) yield 512;
-          }
-          if (start2 % 512) yield start2 % 512;
+        let start2 = 0;
+        while (start2 < content.length && " 	\n\r".includes(content[start2])) {
+          start2++;
+          if (start2 % 512 === 0) yield 512;
+        }
+        if (start2 % 512) yield start2 % 512;
+        const text = content.slice(start2);
+        admitText(text);
+        if (retainContent) {
           admitContent();
-          parent.content.push({ kind: "processing-instruction", target, text: content.slice(start2) });
+          (parent?.content ?? (root ? epilog : prolog)).push({ kind: "processing-instruction", target, text });
         }
       }
       offset = end + 2;
@@ -2102,6 +2429,7 @@ function* parseXmlSteps(input, limits = {}) {
         }
         if (raw.length % 512) yield raw.length % 512;
         const value = yield* entities(normalized);
+        admitText(value);
         attributes.set(attribute, value);
         offset = end + 1;
         if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
@@ -2149,7 +2477,7 @@ function* parseXmlSteps(input, limits = {}) {
         yield 1;
       }
       const content = retainContent ? [] : void 0;
-      const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent ? namespaces : emptyNamespaces, ...root === void 0 && declaration !== void 0 ? { declaration } : {} };
+      const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent ? namespaces : emptyNamespaces, ...root === void 0 && retainContent ? { prolog, epilog, ...declaration === void 0 ? {} : { declaration } } : {} };
       const parent = stack.at(-1);
       if (parent) {
         parent.element.children.push(element);
@@ -2335,7 +2663,12 @@ function statusCode(element) {
   return Number(text.split(" ")[1]);
 }
 var WebDavFileSystem = class {
+  async open(path, options) {
+    options.signal?.throwIfAborted();
+    throw new FsError("ENOTSUP", { syscall: "open", path });
+  }
   capabilities = Object.freeze({
+    open: false,
     read: true,
     stat: true,
     readdir: true,
@@ -3949,4 +4282,4 @@ export {
   safeJsNodeCommands,
   createSafeJsNodeCommand
 };
-//# sourceMappingURL=chunk-3BZ5NQ73.js.map
+//# sourceMappingURL=chunk-WECHUK3Y.js.map