@poe-platform/safe-bash 0.1.628 → 0.1.630

package/dist/safe-bash/chunks/chunk-3BZ5NQ73.js

@@ -0,0 +1,3952 @@
+import {
+  UsageError,
+  pathOf,
+  writeDiagnostic
+} from "./chunk-GFZKQIPL.js";
+import {
+  PublicDiagnostic,
+  publicDiagnosticMessage,
+  yieldTurn
+} from "./chunk-UYX72YHY.js";
+import {
+  readBytes,
+  toByteSource,
+  writeBytes
+} from "./chunk-CXMIIXJA.js";
+import {
+  import_buffer,
+  init_platform
+} from "./chunk-2KL6W6NB.js";
+
+// packages/safe-bash/src/commands/node/browser.ts
+init_platform();
+
+// packages/safe-bash/src/commands/node/safejs.ts
+init_platform();
+
+// packages/safe-bash/src/integrations/safejs/values.ts
+init_platform();
+function record(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${name} must be a plain object`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError(`${name} must be a plain object`);
+  }
+  const result = {};
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || descriptor === void 0 || !("value" in descriptor)) {
+      throw new TypeError(`${name} must contain only string-keyed data properties`);
+    }
+    Object.defineProperty(result, key, {
+      value: descriptor.value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return result;
+}
+function onlyKeys(value, allowed) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key)) throw new TypeError(`Unsupported option: ${key}`);
+  }
+}
+function stringValue(value, name) {
+  if (typeof value !== "string") throw new TypeError(`${name} must be a string`);
+  return value;
+}
+function abortError() {
+  return Object.assign(new Error("The operation was aborted"), {
+    name: "AbortError",
+    code: "ABORT_ERR"
+  });
+}
+function checkSignal(signal) {
+  if (signal?.aborted) throw abortError();
+}
+async function withSignal(signal, operation) {
+  checkSignal(signal);
+  if (signal === void 0) return operation();
+  let onAbort = () => void 0;
+  const cancelled = new Promise((_resolve, reject) => {
+    onAbort = () => reject(abortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(() => {
+      checkSignal(signal);
+      return operation();
+    }), cancelled]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+
+// packages/safe-bash/src/commands/safejs/runtime.ts
+init_platform();
+
+// packages/safe-bash/src/integrations/safejs/index.ts
+init_platform();
+
+// packages/safe-bash/src/integrations/safejs/filesystem.ts
+init_platform();
+
+// packages/safe-js/dist/browser/safe-fs.js
+init_platform();
+
+// packages/safe-js/dist/browser/chunks/chunk-SB2GDI2R.js
+init_platform();
+var platform = Object.freeze({
+  errno(_code) {
+    return void 0;
+  },
+  callbackAuthorities: false,
+  randomUUID() {
+    const crypto = globalThis.crypto;
+    if (typeof crypto?.randomUUID === "function") return crypto.randomUUID();
+    if (typeof crypto?.getRandomValues !== "function") {
+      throw new FsError("ENOTSUP", { message: "secure crypto is required for overlay staging" });
+    }
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+});
+var operationKey = /* @__PURE__ */ Symbol("filesystem-comparison");
+var contexts = /* @__PURE__ */ new WeakSet();
+var comparisonContext = Object.freeze({
+  active(options) {
+    const context = options[operationKey];
+    return context !== void 0 && contexts.has(context);
+  },
+  async run(options, action) {
+    const context = Object.freeze({});
+    contexts.add(context);
+    const nested = { ...options, [operationKey]: context };
+    try {
+      return await action(nested);
+    } finally {
+      contexts.delete(context);
+    }
+  }
+});
+var descriptions = {
+  EACCES: "permission denied",
+  EAGAIN: "resource temporarily unavailable",
+  EBADF: "bad file descriptor",
+  EBUSY: "resource busy or locked",
+  ECANCELED: "operation canceled",
+  EEXIST: "file already exists",
+  EFBIG: "file too large",
+  EINTR: "interrupted system call",
+  EINVAL: "invalid argument",
+  EIO: "input/output error",
+  EISDIR: "illegal operation on a directory",
+  ELOOP: "too many symbolic links encountered",
+  EMFILE: "too many open files",
+  ENAMETOOLONG: "name too long",
+  ENFILE: "file table overflow",
+  ENOENT: "no such file or directory",
+  ENOMEM: "not enough memory",
+  ENOSPC: "no space left on device",
+  ENOSYS: "function not implemented",
+  ENOTDIR: "not a directory",
+  ENOTEMPTY: "directory not empty",
+  ENOTSUP: "operation not supported",
+  EOPNOTSUPP: "operation not supported",
+  EPERM: "operation not permitted",
+  EPIPE: "broken pipe",
+  EROFS: "read-only file system",
+  ESPIPE: "invalid seek",
+  ETIMEDOUT: "operation timed out",
+  EXDEV: "cross-device link not permitted"
+};
+var FsError = class extends Error {
+  code;
+  errno;
+  syscall;
+  path;
+  dest;
+  constructor(code, options = {}) {
+    if (!isErrnoCode(code)) throw new TypeError(`Unsupported errno code: ${String(code)}`);
+    const errno = platform.errno(code);
+    const operation = options.syscall ? `, ${options.syscall}` : "";
+    const path = options.path === void 0 ? "" : ` '${options.path}'`;
+    const destination = options.dest === void 0 ? "" : ` -> '${options.dest}'`;
+    super(`${code}: ${options.message ?? descriptions[code]}${operation}${path}${destination}`, options);
+    this.name = "FsError";
+    this.code = code;
+    this.errno = errno;
+    if (options.syscall !== void 0) this.syscall = options.syscall;
+    if (options.path !== void 0) this.path = options.path;
+    if (options.dest !== void 0) this.dest = options.dest;
+  }
+};
+function isErrnoCode(code) {
+  return typeof code === "string" && Object.hasOwn(descriptions, code);
+}
+function isFsError(error, code) {
+  return error instanceof FsError && (code === void 0 || error.code === code);
+}
+var ACCESS_MODES = Object.freeze({ F_OK: 0, R_OK: 4, W_OK: 2, X_OK: 1 });
+async function finishCleanup(cleanup, failed) {
+  try {
+    await cleanup();
+  } catch (error) {
+    if (!failed) throw error;
+  }
+}
+async function abortable(operation, signal) {
+  signal?.throwIfAborted();
+  if (!signal) return operation();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      Promise.resolve(operation()).then(
+        (result) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve(result);
+        },
+        (error) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(error);
+        }
+      );
+    } catch (error) {
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    }
+  });
+}
+async function* readBytes2(source, signal) {
+  signal?.throwIfAborted();
+  const iterator = source[Symbol.asyncIterator]();
+  let finished = false;
+  let failed = false;
+  try {
+    while (true) {
+      const result = await abortable(() => iterator.next(), signal);
+      if (result.done) {
+        finished = true;
+        return;
+      }
+      if (!(result.value instanceof Uint8Array)) throw new TypeError("Byte sources must yield Uint8Array chunks");
+      yield result.value;
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    if (!finished && iterator.return) {
+      const cleanup = Promise.resolve().then(() => iterator.return());
+      if (signal?.aborted) void cleanup.catch(() => {
+      });
+      else await finishCleanup(() => abortable(() => cleanup, signal), failed);
+    }
+  }
+}
+function dirname(path) {
+  if (typeof path !== "string") throw new TypeError("path must be a string");
+  let end = path.length;
+  while (end > 0 && path[end - 1] === "/") end--;
+  if (end === 0) return path.startsWith("/") ? "/" : ".";
+  const boundary = path.lastIndexOf("/", end - 1);
+  if (boundary < 0) return ".";
+  if (boundary === 0) return "/";
+  if (boundary === 1 && path.startsWith("/")) return "//";
+  return path.slice(0, boundary);
+}
+function assertString(value) {
+  if (typeof value !== "string") throw new TypeError("path must be a string");
+}
+function basename(path, suffix = "") {
+  assertString(path);
+  assertString(suffix);
+  if (suffix && path === suffix) return "";
+  let end = path.length;
+  while (end > 0 && path[end - 1] === "/") end--;
+  if (end === 0 && suffix && suffix.length <= path.length) return path;
+  const start = path.lastIndexOf("/", end - 1) + 1;
+  const base = path.slice(start, end);
+  if (suffix.length > base.length && suffix.length <= path.length && suffix.endsWith(base)) return path.slice(start);
+  return suffix && suffix.length < base.length && base.endsWith(suffix) ? base.slice(0, -suffix.length) : base;
+}
+var dirname2 = dirname;
+function extname(path) {
+  const base = basename(path);
+  const position = base.lastIndexOf(".");
+  return position <= 0 || base === ".." ? "" : base.slice(position);
+}
+function isAbsolutePath(path) {
+  assertString(path);
+  return path.startsWith("/");
+}
+function joinPath(...paths) {
+  for (const path of paths) assertString(path);
+  const joined = paths.filter(Boolean).join("/");
+  if (!joined) return ".";
+  const absolute = joined.startsWith("/");
+  const components2 = [];
+  for (const component of joined.split("/")) {
+    if (!component || component === ".") continue;
+    if (component === "..") {
+      if (components2.length && components2.at(-1) !== "..") components2.pop();
+      else if (!absolute) components2.push(component);
+    } else components2.push(component);
+  }
+  const result = `${absolute ? "/" : ""}${components2.join("/")}` || ".";
+  return joined.endsWith("/") && result !== "/" ? `${result}/` : result;
+}
+var posixPath2 = Object.freeze({ basename, dirname: dirname2, extname, join: joinPath, isAbsolute: isAbsolutePath });
+function complete(stat) {
+  const { identityScope, dev, ino } = stat;
+  return (typeof identityScope === "object" && identityScope !== null || typeof identityScope === "symbol") && typeof dev === "number" && Number.isSafeInteger(dev) && dev >= 0 && typeof ino === "number" && Number.isSafeInteger(ino) && ino >= 0;
+}
+function compareIdentity(left, right) {
+  if (!left || !right || !complete(left) || !complete(right)) return "unknown";
+  return left.identityScope === right.identityScope && left.dev === right.dev && left.ino === right.ino ? "same" : "distinct";
+}
+var resolvers = /* @__PURE__ */ new WeakMap();
+var authorities = /* @__PURE__ */ new WeakMap();
+function assertCallbackAuthorityAllowed() {
+  if (!platform.callbackAuthorities) throw new FsError("ENOTSUP", { message: "custom comparison authorities require Node context" });
+}
+function registerEntryAuthority(filesystem, authority) {
+  if (authorities.has(filesystem)) throw new TypeError("entry authority already registered");
+  authorities.set(filesystem, authority);
+}
+async function resolveEntryView(filesystem, path, options = {}) {
+  let location = { filesystem, path };
+  let readOnly2 = false;
+  const visited = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    options.signal?.throwIfAborted();
+    if (visited.has(location.filesystem)) throw new FsError("EIO", { path, message: "cyclic entry view" });
+    visited.add(location.filesystem);
+    readOnly2 ||= location.readOnly === true || location.filesystem.capabilities.readOnly === true;
+    if (location.stat) return { filesystem: location.filesystem, path: location.path, stat: location.stat, readOnly: readOnly2 };
+    const resolve = resolvers.get(location.filesystem);
+    if (!resolve) {
+      let stat;
+      let followedPath;
+      try {
+        followedPath = await location.filesystem.realpath(location.path, options);
+        options.signal?.throwIfAborted();
+        stat = await location.filesystem.lstat(followedPath, options);
+      } catch (error) {
+        options.signal?.throwIfAborted();
+        throw error;
+      }
+      options.signal?.throwIfAborted();
+      if (stat.type === "symlink") throw new FsError("EIO", { path, message: "followed entry changed during observation" });
+      return { filesystem: location.filesystem, path: followedPath, stat, readOnly: readOnly2 };
+    }
+    let next;
+    try {
+      next = await resolve(location.path, options);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      throw error;
+    }
+    options.signal?.throwIfAborted();
+    if (next.filesystem === location.filesystem && next.stat) {
+      return { filesystem: next.filesystem, path: next.path, stat: next.stat, readOnly: readOnly2 || next.readOnly === true };
+    }
+    location = next;
+  }
+}
+async function compareResolvedEntries(own, peer, options = {}) {
+  options.signal?.throwIfAborted();
+  if (comparisonContext.active(options)) return "unknown";
+  const identity = compareIdentity(own.stat, peer.stat);
+  if (identity !== "unknown") return identity;
+  return comparisonContext.run(options, async (options2) => {
+    const queried = /* @__PURE__ */ new Set();
+    let result = "unknown";
+    for (const [left, right] of [[own, peer], [peer, own]]) {
+      options2.signal?.throwIfAborted();
+      const authority = authorities.get(left.filesystem);
+      const key = authority ?? left.filesystem;
+      if (queried.has(key)) continue;
+      queried.add(key);
+      let answer;
+      try {
+        if (authority) answer = await authority(left, right, options2);
+        else if (left.filesystem.compareEntry) {
+          assertCallbackAuthorityAllowed();
+          answer = await left.filesystem.compareEntry(left.path, right.filesystem, right.path, options2);
+        } else continue;
+      } catch (error) {
+        options2.signal?.throwIfAborted();
+        throw error;
+      }
+      options2.signal?.throwIfAborted();
+      if (answer !== "same" && answer !== "distinct" && answer !== "unknown") {
+        throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid entry comparison answer" });
+      }
+      if (answer === "unknown") continue;
+      if (result !== "unknown" && result !== answer) {
+        throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting entry comparison answers" });
+      }
+      result = answer;
+    }
+    return result;
+  });
+}
+async function compareEntries(filesystem, path, peer, peerPath, options = {}) {
+  options.signal?.throwIfAborted();
+  if (comparisonContext.active(options)) return "unknown";
+  const own = await resolveEntryView(filesystem, path, options);
+  const other = await resolveEntryView(peer, peerPath, options);
+  return compareResolvedEntries(own, other, options);
+}
+var entries = /* @__PURE__ */ new WeakMap();
+function getOwnedS3Entry(view) {
+  return entries.get(view.filesystem)?.(view);
+}
+var responses = /* @__PURE__ */ new WeakMap();
+var observations = /* @__PURE__ */ new WeakMap();
+function recordOwnedResourceStat(response, filesystem, path, stat) {
+  const entry = responses.get(response)?.get(path);
+  if (entry) observations.set(stat, { filesystem, path, entry });
+}
+function getOwnedWebDavEntry(view) {
+  const observation = observations.get(view.stat);
+  return observation?.filesystem === view.filesystem && observation.path === view.path ? observation.entry : void 0;
+}
+function ownedResponseIdentifier(response, path) {
+  return responses.get(response)?.get(path)?.identifier;
+}
+var queries = /* @__PURE__ */ new WeakMap();
+var comparisons = /* @__PURE__ */ new WeakMap();
+var callbacks = /* @__PURE__ */ new WeakMap();
+function registerResourceQuery(filesystem, query, baseComparison, callback) {
+  comparisons.set(filesystem, baseComparison);
+  if (callback) callbacks.set(filesystem, callback);
+  queries.set(filesystem, async (path, options) => {
+    options.signal?.throwIfAborted();
+    const identifier = await query(path, options);
+    options.signal?.throwIfAborted();
+    return identifier;
+  });
+}
+function resourceIdentifier(value) {
+  if (!/^[A-Za-z][A-Za-z0-9+.-]*:[^\s<>"{}|\\^`]+$/.test(value) || /%(?![0-9A-Fa-f]{2})/.test(value) || /[^\x21-\x7e]/.test(value)) throw new Error("invalid DAV:resource-id URI");
+  new URL(value);
+  if (/^urn:uuid:/i.test(value)) {
+    if (!/^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+      throw new Error("invalid DAV:resource-id UUID");
+    }
+    return value.toLowerCase();
+  }
+  return value;
+}
+var compareWebDavResources = async (own, peer, options) => {
+  options.signal?.throwIfAborted();
+  let explicit = false;
+  let answer = "unknown";
+  const visited = /* @__PURE__ */ new Set();
+  for (const [left, right] of [[own, peer], [peer, own]]) {
+    const baseComparison = comparisons.get(left.filesystem);
+    if (!baseComparison) continue;
+    const method = left.filesystem.compareEntry;
+    const comparison = method === baseComparison ? callbacks.get(left.filesystem) : method;
+    if (method === baseComparison && !comparison) continue;
+    explicit = true;
+    if (!comparison || visited.has(left.filesystem)) continue;
+    visited.add(left.filesystem);
+    options.signal?.throwIfAborted();
+    assertCallbackAuthorityAllowed();
+    const result = await comparison.call(left.filesystem, left.path, right.filesystem, right.path, options);
+    options.signal?.throwIfAborted();
+    if (result !== "same" && result !== "distinct" && result !== "unknown") {
+      throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid explicit WebDAV comparison" });
+    }
+    if (result === "unknown") continue;
+    if (answer !== "unknown" && answer !== result) {
+      throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting explicit WebDAV comparisons" });
+    }
+    answer = result;
+  }
+  const builtin = await compareProtocolEntries(own, peer, options);
+  if (builtin === "same" && answer === "distinct") {
+    throw new FsError("EIO", { path: own.path, dest: peer.path, message: "explicit WebDAV comparison contradicts built-in identity" });
+  }
+  if (builtin === "same") return "same";
+  return explicit ? answer : builtin;
+};
+async function compareProtocolEntries(own, peer, options) {
+  const left = getOwnedWebDavEntry(own);
+  const right = getOwnedWebDavEntry(peer);
+  const ownQuery = queries.get(own.filesystem);
+  const peerQuery = queries.get(peer.filesystem);
+  if (!ownQuery || !peerQuery) return "unknown";
+  options.signal?.throwIfAborted();
+  const ownId = await ownQuery(own.path, options);
+  options.signal?.throwIfAborted();
+  const peerId = await peerQuery(peer.path, options);
+  options.signal?.throwIfAborted();
+  if (ownId === void 0 || peerId === void 0) return "unknown";
+  if (left && right) {
+    const same = left.storage === right.storage && left.resource === right.resource;
+    if (same !== (ownId === peerId)) throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting owned and protocol WebDAV identities" });
+  }
+  return ownId === peerId ? "same" : "distinct";
+}
+function directoryEntryLimit(options, path) {
+  options.signal?.throwIfAborted();
+  const limit = options.maxEntries;
+  if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 0)) {
+    throw new FsError("EINVAL", { syscall: "readdir", path, message: "directory entry limit must be a nonnegative safe integer" });
+  }
+  return limit;
+}
+function admitDirectoryEntries(count, limit, path) {
+  if (limit !== void 0 && count > limit) {
+    throw new FsError("EFBIG", { syscall: "readdir", path, message: "directory entry limit exceeded" });
+  }
+}
+function components(path, signal) {
+  const result = [];
+  let start = 0;
+  for (let offset = 0; offset <= path.length; offset++) {
+    signal?.throwIfAborted();
+    if (offset !== path.length && path.charCodeAt(offset) !== 47) continue;
+    if (offset > start) result.push({ name: path.slice(start, offset), start });
+    start = offset + 1;
+  }
+  return result;
+}
+function resolveMissingTarget(root, path, signal) {
+  const fail4 = (code, failedPath = path) => {
+    throw new FsError(code, { syscall: "realpath", path: failedPath });
+  };
+  const origin = components(path, signal);
+  const initial = { node: root, name: "" };
+  let position = initial;
+  let links = 0;
+  let missing = origin.length;
+  let missingLink = false;
+  for (let index = 0; index <= origin.length; index++) {
+    const token = origin[index];
+    if (!token && path.length > 0 && !path.endsWith("/")) break;
+    const before = position;
+    const frames = [{ names: [token ?? { name: ".", start: path.length }], next: 0 }];
+    let first = true;
+    let originLink = false;
+    let found = true;
+    while (frames.length > 0) {
+      signal?.throwIfAborted();
+      const frame = frames.at(-1);
+      if (!frame) break;
+      const component = frame.names[frame.next++];
+      if (!component) {
+        frames.pop();
+        continue;
+      }
+      const current = position.node;
+      if (current.type !== "directory") return fail4("ENOTDIR");
+      if ((current.mode >> 6 & 1) !== 1) return fail4("EACCES");
+      const name = component.name;
+      if (name === ".") {
+        first = false;
+        continue;
+      }
+      if (name === "..") {
+        position = position.parent ?? initial;
+        first = false;
+        continue;
+      }
+      if (new TextEncoder().encode(name).byteLength > 255) return fail4("ENAMETOOLONG");
+      const node = current.entries.get(name);
+      if (!node) {
+        found = false;
+        break;
+      }
+      if (first) originLink = node.type === "symlink";
+      first = false;
+      if (node.type === "symlink") {
+        if (++links > 40) return fail4("ELOOP");
+        const names2 = components(node.target, signal);
+        if (node.target.endsWith("/")) names2.push({ name: ".", start: node.target.length });
+        if (node.target.startsWith("/")) position = initial;
+        frames.push({ names: names2, next: 0 });
+      } else position = { node, name, parent: position };
+    }
+    if (!found) {
+      position = before;
+      missing = index;
+      missingLink = originLink;
+      break;
+    }
+  }
+  if (missingLink) {
+    let end = path.length;
+    for (let count = origin.length; count > missing; count--) {
+      signal?.throwIfAborted();
+      if (count === missing + 1 && path[end - 1] !== "/") return fail4("ENOENT", path.slice(0, end));
+      const last = origin[count - 1];
+      if (!last) break;
+      const boundary = last.start - 1;
+      end = boundary <= 0 ? 1 : boundary === 1 && path.startsWith("/") ? 2 : boundary;
+    }
+  }
+  const names = [];
+  for (let current = position; current?.parent; current = current.parent) {
+    signal?.throwIfAborted();
+    names.push(current.name);
+  }
+  names.reverse();
+  for (let index = missing; index < origin.length; index++) {
+    signal?.throwIfAborted();
+    const name = origin[index]?.name;
+    if (name === "..") names.pop();
+    else if (name && name !== ".") names.push(name);
+  }
+  return `/${names.join("/")}`;
+}
+var MemoryLedger = class {
+  constructor(limits) {
+    this.limits = limits;
+  }
+  limits;
+  retainedBytes = 0;
+  metadataUnits = 0;
+  get availableBytes() {
+    return this.limits.maxRetainedBytes - this.retainedBytes;
+  }
+  fileSize(length, syscall, path) {
+    if (!Number.isSafeInteger(length) || length < 0 || length > this.limits.maxFileBytes) {
+      throw new FsError("EFBIG", { syscall, path });
+    }
+  }
+  check(bytes, units, syscall, path) {
+    if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.availableBytes || !Number.isSafeInteger(units) || units < 0 || units > this.limits.maxMetadataUnits - this.metadataUnits) {
+      throw new FsError("ENOSPC", { syscall, path });
+    }
+  }
+  reserve(bytes, units, syscall, path) {
+    this.check(bytes, units, syscall, path);
+    this.retainedBytes += bytes;
+    this.metadataUnits += units;
+  }
+  release(bytes, units) {
+    if (bytes < 0 || units < 0 || bytes > this.retainedBytes || units > this.metadataUnits) {
+      throw new Error("Invalid Memory filesystem reservation release");
+    }
+    this.retainedBytes -= bytes;
+    this.metadataUnits -= units;
+  }
+};
+var MemoryAllocation = class {
+  constructor(data, ledger) {
+    this.data = data;
+    this.ledger = ledger;
+  }
+  data;
+  ledger;
+  references = 1;
+  retain() {
+    this.references++;
+  }
+  release() {
+    if (this.references <= 0) throw new Error("Memory allocation already released");
+    if (--this.references === 0) this.ledger.release(this.data.byteLength, 0);
+  }
+};
+function readConfigRecord(value, label, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${label} must be a record.`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError(`${label} must be a plain record.`);
+  }
+  const record2 = /* @__PURE__ */ Object.create(null);
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string" || keys !== void 0 && !keys.includes(key)) {
+      throw new TypeError(`Unknown ${label}: ${String(key)}`);
+    }
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in property)) throw new TypeError(`${label}.${key} must be a data property.`);
+    record2[key] = property.value;
+  }
+  return Object.freeze(record2);
+}
+var defaultMemoryFileSystemLimits = Object.freeze({
+  maxFileBytes: 16 * 1024 * 1024,
+  maxRetainedBytes: 64 * 1024 * 1024,
+  maxMetadataUnits: 1e4
+});
+function normalizeMemoryFileSystemLimits(options) {
+  const keys = ["maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
+  const record2 = readConfigRecord(options, "memory option", keys);
+  const limits = { ...defaultMemoryFileSystemLimits };
+  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)) {
+      throw new RangeError(`${key} must be a ${key === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer`);
+    }
+    limits[key] = value;
+  }
+  return Object.freeze(limits);
+}
+var typeModes = { file: 32768, directory: 16384, symlink: 40960 };
+var ext4HtreeEof64 = (1n << 63n) - 1n;
+var ownedStats = /* @__PURE__ */ new WeakMap();
+var ownedStores = /* @__PURE__ */ new WeakMap();
+var registeredAuthorities = /* @__PURE__ */ new WeakSet();
+var compareOwnedMemory = async (own, peer, options) => {
+  options.signal?.throwIfAborted();
+  let explicit = false;
+  let answer = "unknown";
+  const visited = /* @__PURE__ */ new Set();
+  for (const [left, right] of [[own, peer], [peer, own]]) {
+    if (!registeredAuthorities.has(left.filesystem) || visited.has(left.filesystem)) continue;
+    visited.add(left.filesystem);
+    const comparison = left.filesystem.compareEntry;
+    if (comparison === memoryImplementation.compareEntry?.value) continue;
+    explicit = true;
+    if (!comparison) continue;
+    options.signal?.throwIfAborted();
+    assertCallbackAuthorityAllowed();
+    const result = await comparison.call(left.filesystem, left.path, right.filesystem, right.path, options);
+    options.signal?.throwIfAborted();
+    if (result !== "same" && result !== "distinct" && result !== "unknown") {
+      throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid explicit Memory comparison" });
+    }
+    if (result === "unknown") continue;
+    if (answer !== "unknown" && answer !== result) {
+      throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting explicit Memory comparisons" });
+    }
+    answer = result;
+  }
+  if (explicit) return answer;
+  const owner = ownedStores.get(own.filesystem);
+  const observation = ownedStats.get(own.stat);
+  if (!owner?.intact() || observation?.filesystem !== own.filesystem || observation.path !== own.path || observation.root !== owner.root) return "unknown";
+  const qualified = getOwnedS3Entry(peer) ?? getOwnedWebDavEntry(peer);
+  options.signal?.throwIfAborted();
+  return qualified ? "distinct" : "unknown";
+};
+var MemoryFileSystem = class _MemoryFileSystem {
+  capabilities = ((filesystem) => {
+    return Object.freeze({
+      read: true,
+      stat: true,
+      readdir: true,
+      realpath: true,
+      access: true,
+      write: true,
+      append: true,
+      exclusiveCreate: true,
+      explicitDirectories: true,
+      implicitDirectories: false,
+      mkdir: true,
+      recursiveMkdir: true,
+      remove: true,
+      removeDirectory: true,
+      recursiveRemove: true,
+      rename: true,
+      atomicRenameNoReplace: true,
+      copy: true,
+      exclusiveCopy: true,
+      readlink: true,
+      truncate: true,
+      streamingAppend: true,
+      randomAccessWrite: true,
+      readOnly: false,
+      symlinks: true,
+      hardlinks: true,
+      permissions: true,
+      timestamps: true,
+      atomicRename: true,
+      atomicFileStaging: true,
+      atomicFileMutation: true,
+      atomicDirectoryMetadata: true,
+      streamingRead: true,
+      retainedRead: true,
+      get retainedResize() {
+        return stockRetainedResize(filesystem);
+      },
+      streamingWrite: true,
+      get descriptorWriteStream() {
+        return stockDescriptorWrite(filesystem);
+      }
+    });
+  })(this);
+  identityScope = /* @__PURE__ */ Symbol();
+  nextInode = 1;
+  ledger;
+  root;
+  constructor(options = {}) {
+    this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
+    this.ledger.reserve(0, 1, "mkdir", "/");
+    this.root = this.directory(493);
+    const root = this.root;
+    ownedStores.set(this, {
+      root,
+      ledger: this.ledger,
+      capabilities: this.capabilities,
+      intact: () => this.root === root
+    });
+    if (this.compareEntry === memoryImplementation.compareEntry?.value) {
+      registeredAuthorities.add(this);
+      registerEntryAuthority(this, compareOwnedMemory);
+    }
+  }
+  compareEntry(path, peer, peerPath, options = {}) {
+    return compareEntries(this, path, peer, peerPath, options);
+  }
+  canonicalizeMissingTarget(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const owner = ownedStores.get(this);
+    if (!owner || Object.getPrototypeOf(this) !== _MemoryFileSystem.prototype || Object.getOwnPropertyDescriptor(this, "root")?.value !== owner.root) return void 0;
+    for (const name of ["realpath", "lstat", "resolve", "permission", "validatePath", "fail", "snapshot"]) {
+      const descriptor = Object.getOwnPropertyDescriptor(this, name) ?? Object.getOwnPropertyDescriptor(_MemoryFileSystem.prototype, name);
+      if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value) return void 0;
+    }
+    if (path !== "") this.validatePath(path, "realpath");
+    return resolveMissingTarget(owner.root, path || ".", options.signal);
+  }
+  metadata(mode2) {
+    const now = Date.now();
+    return {
+      mode: mode2,
+      ino: this.nextInode++,
+      nlink: 1,
+      references: 0,
+      revision: 0,
+      atimeMs: now,
+      mtimeMs: now,
+      ctimeMs: now,
+      birthtimeMs: now
+    };
+  }
+  directory(mode2) {
+    return { ...this.metadata(typeModes.directory | mode2), type: "directory", entries: /* @__PURE__ */ new Map() };
+  }
+  addNode(parent, name, create, syscall, path, retainedBytes = 0) {
+    const bytes = name.length * 2 + retainedBytes;
+    this.ledger.reserve(bytes, 2, syscall, path);
+    try {
+      const node = create();
+      parent.entries.set(name, node);
+      this.changed(parent);
+      return node;
+    } catch (error) {
+      this.ledger.release(bytes, 2);
+      throw error;
+    }
+  }
+  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();
+  }
+  releaseReference(node, path) {
+    node.references--;
+    this.ledger.release(path.length * 2, 1);
+    this.releaseNode(node);
+  }
+  replaceData(node, allocation, length = allocation.data.byteLength) {
+    const previous = node.allocation;
+    node.data = allocation.data.subarray(0, length);
+    node.allocation = allocation;
+    previous.release();
+  }
+  fail(code, syscall, path, dest) {
+    throw new FsError(code, { syscall, path, ...dest === void 0 ? {} : { dest } });
+  }
+  validatePath(path, syscall) {
+    if (typeof path !== "string" || path.includes("\0")) this.fail("EINVAL", syscall, path);
+    if (path.length === 0) this.fail("ENOENT", syscall, path);
+  }
+  permission(node, mask, syscall, path) {
+    if ((node.mode >> 6 & mask) !== mask) this.fail("EACCES", syscall, path);
+  }
+  mode(mode2, fallback, syscall, path) {
+    const value = mode2 ?? fallback;
+    if (!Number.isInteger(value) || value < 0 || value > 4095) this.fail("EINVAL", syscall, path);
+    return value;
+  }
+  integer(value, syscall, path) {
+    if (!Number.isSafeInteger(value) || value < 0) this.fail("EINVAL", syscall, path);
+  }
+  changed(node) {
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    node.mtimeMs = node.ctimeMs = Date.now();
+  }
+  resolve(path, syscall, options = {}) {
+    this.validatePath(path, syscall);
+    const pending = path.split("/").filter(Boolean);
+    if (path.endsWith("/")) pending.push("");
+    const stack = [{ node: this.root, name: "" }];
+    let links = 0;
+    while (pending.length > 0) {
+      const component = pending.shift();
+      const current = stack[stack.length - 1].node;
+      if (current.type !== "directory") this.fail("ENOTDIR", syscall, path);
+      if (!(component === "" && pending.length === 0 && options.resizeCreate !== void 0)) this.permission(current, 1, syscall, path);
+      if (component === "." || component === "") continue;
+      if (component === "..") {
+        if (stack.length > 1) stack.pop();
+        continue;
+      }
+      if (new TextEncoder().encode(component).byteLength > 255) this.fail("ENAMETOOLONG", syscall, path);
+      if (options.resizeCreate === true && pending.length === 1 && pending[0] === "") this.fail("EISDIR", syscall, path);
+      let node = current.entries.get(component);
+      if (!node && options.createDirectories !== void 0) {
+        this.permission(current, 3, syscall, path);
+        const mode2 = options.createDirectories;
+        node = this.addNode(current, component, () => this.directory(mode2), syscall, path);
+      }
+      if (!node) {
+        if (options.allowMissing && pending.length === 0) {
+          return { node, parent: current, name: component, path: [...stack.map((entry2) => entry2.name), component].join("/") };
+        }
+        this.fail("ENOENT", syscall, path);
+      }
+      if (node.type === "symlink" && (options.followFinal !== false || pending.length > 0)) {
+        if (++links > 40) this.fail("ELOOP", syscall, path);
+        const target = node.target.split("/").filter(Boolean);
+        if (node.target.endsWith("/")) target.push("");
+        if (options.resizeCreate !== void 0 && target.at(-1) === "" && pending[0] === "") target.pop();
+        pending.unshift(...target);
+        if (node.target.startsWith("/")) stack.splice(1);
+        continue;
+      }
+      stack.push({ node, name: component });
+    }
+    const entry = stack[stack.length - 1];
+    return {
+      node: entry.node,
+      parent: stack[stack.length - 2]?.node ?? this.root,
+      name: entry.name,
+      path: stack.map((part) => part.name).join("/") || "/"
+    };
+  }
+  file(path, syscall) {
+    const node = this.resolve(path, syscall).node;
+    if (node.type !== "file") this.fail("EISDIR", syscall, path);
+    return node;
+  }
+  entry(path, syscall, allowMissing = false) {
+    this.validatePath(path, syscall);
+    const location = this.resolve(path.replace(/\/+$/, "") || "/", syscall, { followFinal: false, allowMissing });
+    if (path.endsWith("/") && location.node && location.node.type !== "directory") this.fail("ENOTDIR", syscall, path);
+    return location;
+  }
+  terminalDot(path) {
+    return /(?:^|\/)\.{1,2}\/*$/.test(path);
+  }
+  snapshot(node) {
+    return {
+      type: node.type,
+      ...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,
+      mode: node.mode,
+      ...ownedStores.get(this)?.intact() ? { identityScope: this.identityScope } : {},
+      ino: node.ino,
+      dev: 0,
+      uid: 0,
+      gid: 0,
+      nlink: node.type === "directory" && node.nlink !== 0 ? 2 + [...node.entries.values()].filter((entry) => entry.type === "directory").length : node.nlink,
+      atimeMs: node.atimeMs,
+      mtimeMs: node.mtimeMs,
+      ctimeMs: node.ctimeMs,
+      birthtimeMs: node.birthtimeMs
+    };
+  }
+  bytes(data, syscall, path) {
+    const allocation = this.allocate(data.byteLength, syscall, path);
+    try {
+      allocation.data.set(data);
+      return allocation;
+    } catch (error) {
+      allocation.release();
+      throw error;
+    }
+  }
+  allocate(length, syscall, path) {
+    this.ledger.fileSize(length, syscall, path);
+    this.ledger.reserve(length, 0, syscall, path);
+    try {
+      return new MemoryAllocation(new Uint8Array(length), this.ledger);
+    } catch (cause) {
+      this.ledger.release(length, 0);
+      throw new FsError("EFBIG", { syscall, path, cause });
+    }
+  }
+  prepareWrite(path, options, syscall) {
+    const flag = options.flag ?? "w";
+    if (!["w", "wx", "a", "ax"].includes(flag)) this.fail("EINVAL", syscall, path);
+    const mode2 = this.mode(options.mode, 438, syscall, path);
+    const exclusive = flag === "wx" || flag === "ax";
+    const location = this.resolve(path, syscall, { followFinal: !exclusive, allowMissing: true });
+    if (location.node) {
+      if (exclusive) this.fail("EEXIST", syscall, path);
+      if (location.node.type !== "file") this.fail("EISDIR", syscall, path);
+      this.permission(location.node, 2, syscall, path);
+    } else {
+      this.permission(location.parent, 3, syscall, path);
+    }
+    return { location, mode: mode2, append: flag === "a" || flag === "ax" };
+  }
+  openWrite(path, options, syscall, target = this.prepareWrite(path, options, syscall)) {
+    const { location, mode: mode2 } = target;
+    if (location.node) return location.node;
+    return this.addNode(location.parent, location.name, () => {
+      const allocation = new MemoryAllocation(new Uint8Array(), this.ledger);
+      return { ...this.metadata(typeModes.file | mode2), type: "file", data: allocation.data, allocation };
+    }, syscall, path);
+  }
+  writeData(path, data, options, syscall) {
+    if (!(data instanceof Uint8Array)) throw new TypeError("Memory files require Uint8Array data");
+    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);
+    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);
+    let allocation = copied;
+    let transferred = false;
+    try {
+      if (!current) {
+        if (target.append && length > 0) {
+          const capacity = Math.min(
+            Math.max(length, 64),
+            this.ledger.limits.maxFileBytes,
+            this.ledger.availableBytes - target.location.name.length * 2
+          );
+          allocation = this.allocate(capacity, syscall, path);
+          allocation.data.set(copied.data);
+        }
+        const node = this.addNode(target.location.parent, target.location.name, () => ({
+          ...this.metadata(typeModes.file | target.mode),
+          type: "file",
+          data: allocation.data.subarray(0, length),
+          allocation
+        }), syscall, path);
+        transferred = true;
+        return node;
+      }
+      if (target.append) this.writeAt(current, copied.data, current.data.byteLength, syscall, path);
+      else {
+        this.replaceData(current, copied);
+        transferred = true;
+        this.changed(current);
+      }
+      return current;
+    } finally {
+      if (allocation !== copied && !transferred) allocation.release();
+      if (!transferred || allocation !== copied) copied.release();
+    }
+  }
+  writeAt(node, data, position, syscall, path) {
+    if (data.byteLength === 0) {
+      this.changed(node);
+      return;
+    }
+    const end = position + data.byteLength;
+    this.ledger.fileSize(end, syscall, path);
+    const length = Math.max(node.data.byteLength, end);
+    let allocation = node.allocation;
+    if (length > allocation.data.byteLength) {
+      this.ledger.check(length, 0, syscall, path);
+      const capacity = Math.min(
+        Math.max(length, node.data.byteLength * 2, 64),
+        this.ledger.limits.maxFileBytes,
+        this.ledger.availableBytes
+      );
+      allocation = this.allocate(capacity, syscall, path);
+    }
+    try {
+      const storage = allocation.data;
+      if (allocation !== node.allocation) storage.set(node.data);
+      if (position > node.data.byteLength) storage.fill(0, node.data.byteLength, position);
+      storage.set(data, position);
+    } catch (error) {
+      if (allocation !== node.allocation) allocation.release();
+      throw error;
+    }
+    if (allocation !== node.allocation) this.replaceData(node, allocation, length);
+    else node.data = allocation.data.subarray(0, length);
+    this.changed(node);
+  }
+  async readFile(path, options = {}) {
+    options.signal?.throwIfAborted();
+    if (options.maxBytes !== void 0) this.integer(options.maxBytes, "readFile", path);
+    const node = this.file(path, "readFile");
+    this.permission(node, 4, "readFile", path);
+    if (options.maxBytes !== void 0 && node.data.byteLength > options.maxBytes) this.fail("EFBIG", "readFile", path);
+    node.atimeMs = Date.now();
+    return new Uint8Array(node.data);
+  }
+  expectEntry(node, expected, path, unchanged = true) {
+    if (expected === null) {
+      if (node) this.fail("EAGAIN", "fileStaging", path);
+      return;
+    }
+    if (!node) this.fail("EAGAIN", "fileStaging", path);
+    const current = this.snapshot(node);
+    if (!expected.identityScope || expected.identityScope !== current.identityScope || !Number.isSafeInteger(expected.ino) || !Number.isSafeInteger(expected.dev)) this.fail("ENOTSUP", "fileStaging", path);
+    if (current.ino !== expected.ino || current.dev !== expected.dev || current.type !== expected.type) this.fail("EAGAIN", "fileStaging", path);
+    if (unchanged) {
+      if (!Number.isSafeInteger(expected.revision) || !Number.isSafeInteger(current.revision)) this.fail("ENOTSUP", "fileStaging", path);
+      if (current.revision !== expected.revision || current.size !== expected.size || current.mode !== expected.mode || current.nlink !== expected.nlink || current.mtimeMs !== expected.mtimeMs || current.ctimeMs !== expected.ctimeMs) this.fail("EAGAIN", "fileStaging", path);
+    }
+  }
+  stagingLocations(staging) {
+    const parent = this.entry(staging.parent.path, "fileStaging");
+    this.expectEntry(parent.node, staging.parent.stat, staging.parent.path, false);
+    if (parent.node.type !== "directory") this.fail("ENOTDIR", "fileStaging", staging.parent.path);
+    const directory = this.entry(staging.directory.path, "fileStaging");
+    this.expectEntry(directory.node, staging.directory.stat, staging.directory.path, false);
+    if (directory.parent !== parent.node || directory.node.type !== "directory" || (directory.node.mode & 511) !== 448) this.fail("EAGAIN", "fileStaging", staging.directory.path);
+    const file = this.entry(staging.file.path, "fileStaging", true);
+    if (file.parent !== directory.node || !["file", "symlink"].includes(staging.file.stat.type)) this.fail("EAGAIN", "fileStaging", staging.file.path);
+    return { directory, file };
+  }
+  async createStagedFile(directoryPath, name, content, options) {
+    options.signal?.throwIfAborted();
+    if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0")) this.fail("EINVAL", "createStagedFile", directoryPath);
+    const location = this.entry(directoryPath, "createStagedFile", true);
+    if (location.node) this.fail("EEXIST", "createStagedFile", directoryPath);
+    this.expectEntry(location.parent, options.parent, directoryPath, false);
+    this.permission(location.parent, 3, "createStagedFile", directoryPath);
+    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 === "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);
+    let allocation;
+    let directory;
+    let file;
+    try {
+      if (content.type === "file") allocation = this.bytes(content.data, "createStagedFile", directoryPath);
+      directory = this.directory(448);
+      file = content.type === "file" ? { ...this.metadata(typeModes.file | mode2), type: "file", data: allocation.data, allocation } : { ...this.metadata(typeModes.symlink | mode2), type: "symlink", target: content.target };
+      if (options.atimeMs !== void 0) file.atimeMs = options.atimeMs;
+      if (options.mtimeMs !== void 0) file.mtimeMs = options.mtimeMs;
+      directory.entries.set(name, file);
+      location.parent.entries.set(location.name, directory);
+    } catch (error) {
+      allocation?.release();
+      this.ledger.release(retained, 4);
+      throw error;
+    }
+    this.changed(location.parent);
+    const parentPath = location.path.slice(0, location.path.lastIndexOf("/")) || "/";
+    const receipt = (path, node) => Object.freeze({ path, stat: Object.freeze(this.snapshot(node)) });
+    return Object.freeze({ parent: receipt(parentPath, location.parent), directory: receipt(location.path, directory), file: receipt(`${location.path}/${name}`, file) });
+  }
+  async publishStagedFile(staging, destination, options) {
+    options.signal?.throwIfAborted();
+    const { directory, file } = this.stagingLocations(staging);
+    this.expectEntry(file.node, staging.file.stat, staging.file.path);
+    const target = this.entry(destination, "publishStagedFile", true);
+    this.expectEntry(target.parent, options.parent, destination, false);
+    this.expectEntry(target.node, options.destination, destination);
+    if (target.parent === directory.node || target.node === directory.node || target.node === file.node) this.fail("EINVAL", "publishStagedFile", destination);
+    if (target.node && (target.node.type !== "file" || target.node.nlink !== 1)) this.fail("EAGAIN", "publishStagedFile", destination);
+    return _MemoryFileSystem.prototype.rename.call(this, staging.file.path, destination, { ...options, noReplace: options.destination === null });
+  }
+  async removeStagedFile(staging, options = {}) {
+    options.signal?.throwIfAborted();
+    const { directory, file } = this.stagingLocations(staging);
+    if (file.node) this.expectEntry(file.node, staging.file.stat, staging.file.path);
+    const node = directory.node;
+    if (node.entries.size !== (file.node ? 1 : 0)) this.fail("ENOTEMPTY", "removeStagedFile", staging.directory.path);
+    this.permission(directory.parent, 3, "removeStagedFile", staging.directory.path);
+    this.permission(node, 3, "removeStagedFile", staging.file.path);
+    directory.parent.entries.delete(directory.name);
+    if (file.node) {
+      node.entries.delete(file.name);
+      this.ledger.release(file.name.length * 2, 1);
+      file.node.nlink--;
+      file.node.ctimeMs = Date.now();
+      file.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, file.node.revision + 1);
+      this.releaseNode(file.node);
+    }
+    this.ledger.release(directory.name.length * 2, 1);
+    node.nlink = 0;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    this.releaseNode(node);
+    this.changed(directory.parent);
+  }
+  async prepareDirectory(path, options) {
+    options.signal?.throwIfAborted();
+    const location = this.entry(path, "prepareDirectory", true);
+    this.expectEntry(location.parent, options.parent, path, false);
+    this.expectEntry(location.node, options.expected, path, false);
+    const mode2 = options.mode === void 0 ? void 0 : this.mode(options.mode, 0, "prepareDirectory", path);
+    for (const time of [options.atimeMs, options.mtimeMs]) if (time !== void 0 && !Number.isFinite(time)) this.fail("EINVAL", "prepareDirectory", path);
+    let node = location.node;
+    if (!node) {
+      this.permission(location.parent, 3, "prepareDirectory", path);
+      node = this.addNode(location.parent, location.name, () => this.directory(mode2 ?? 511), "prepareDirectory", path);
+    }
+    if (node.type !== "directory") this.fail("ENOTDIR", "prepareDirectory", path);
+    if (mode2 !== void 0) node.mode = typeModes.directory | mode2;
+    if (options.atimeMs !== void 0) node.atimeMs = options.atimeMs;
+    if (options.mtimeMs !== void 0) node.mtimeMs = options.mtimeMs;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    return Object.freeze(this.snapshot(node));
+  }
+  async writeFileConditional(path, data, options) {
+    options.signal?.throwIfAborted();
+    const location = this.entry(path, "writeFileConditional", true);
+    this.expectEntry(location.parent, options.parent, path, false);
+    this.expectEntry(location.node, options.expected, path);
+    if (location.node && location.node.type !== "file") this.fail("EINVAL", "writeFileConditional", path);
+    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 removeFileConditional(path, options) {
+    options.signal?.throwIfAborted();
+    const location = this.entry(path, "removeFileConditional", true);
+    this.expectEntry(location.parent, options.parent, path, false);
+    this.expectEntry(location.node, options.expected, path);
+    const node = location.node;
+    if (node.type !== "file") this.fail("EINVAL", "removeFileConditional", path);
+    this.permission(location.parent, 3, "removeFileConditional", 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 writeFile(path, data, options = {}) {
+    options.signal?.throwIfAborted();
+    this.writeData(path, data, options, "writeFile");
+  }
+  async appendFile(path, data, options = {}) {
+    options.signal?.throwIfAborted();
+    this.writeData(path, data, { ...options, flag: "a" }, "appendFile");
+  }
+  async stat(path, options = {}) {
+    options.signal?.throwIfAborted();
+    return this.snapshot(this.resolve(path, "stat").node);
+  }
+  async lstat(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const stat = this.snapshot(this.resolve(path, "lstat", { followFinal: false }).node);
+    ownedStats.set(stat, { filesystem: this, path, root: this.root });
+    return stat;
+  }
+  async readdir(path, options = {}) {
+    const limit = directoryEntryLimit(options, path);
+    const node = this.resolve(path, "readdir").node;
+    if (node.type !== "directory") this.fail("ENOTDIR", "readdir", path);
+    this.permission(node, 4, "readdir", path);
+    admitDirectoryEntries(node.entries.size, limit, path);
+    node.atimeMs = Date.now();
+    return [...node.entries].map(([name, entry]) => ({ name, type: entry.type })).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  }
+  async mkdir(path, options = {}) {
+    options.signal?.throwIfAborted();
+    this.validatePath(path, "mkdir");
+    const mode2 = this.mode(options.mode, 511, "mkdir", path);
+    if (options.recursive) {
+      const node = this.resolve(path, "mkdir", { createDirectories: mode2 }).node;
+      if (node.type !== "directory") this.fail("EEXIST", "mkdir", path);
+      return;
+    }
+    const location = this.resolve(path.replace(/\/+$/, "") || "/", "mkdir", { allowMissing: true, followFinal: false });
+    if (location.node) this.fail("EEXIST", "mkdir", path);
+    this.permission(location.parent, 3, "mkdir", path);
+    this.addNode(location.parent, location.name, () => this.directory(mode2), "mkdir", path);
+  }
+  async rmdir(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const location = this.entry(path, "rmdir");
+    const node = location.node;
+    if (this.terminalDot(path)) this.fail("EINVAL", "rmdir", path);
+    if (node === this.root) this.fail("EBUSY", "rmdir", path);
+    if (node.type !== "directory") this.fail("ENOTDIR", "rmdir", path);
+    this.permission(location.parent, 3, "rmdir", path);
+    if (node.entries.size > 0) this.fail("ENOTEMPTY", "rmdir", path);
+    location.parent.entries.delete(location.name);
+    this.ledger.release(location.name.length * 2, 1);
+    node.nlink = 0;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    this.releaseNode(node);
+    this.changed(location.parent);
+  }
+  async rm(path, options = {}) {
+    options.signal?.throwIfAborted();
+    let location;
+    try {
+      location = this.entry(path, "rm");
+    } catch (error) {
+      if (options.force && error instanceof FsError && error.code === "ENOENT") return;
+      throw error;
+    }
+    const node = location.node;
+    if (this.terminalDot(path)) this.fail("EINVAL", "rm", path);
+    if (node === this.root) this.fail("EBUSY", "rm", path);
+    this.permission(location.parent, 3, "rm", path);
+    if (node.type === "directory" && !options.recursive) this.fail("EISDIR", "rm", path);
+    const removed = [node];
+    for (let index = 0; index < removed.length; index++) {
+      const entry = removed[index];
+      if (entry.type === "directory" && entry.entries.size > 0) {
+        this.permission(entry, 7, "rm", path);
+        for (const child of entry.entries.values()) removed.push(child);
+      }
+    }
+    location.parent.entries.delete(location.name);
+    this.ledger.release(location.name.length * 2, 1);
+    for (const entry of removed) {
+      if (entry.type === "directory") {
+        for (const name of entry.entries.keys()) this.ledger.release(name.length * 2, 1);
+        entry.entries.clear();
+      }
+      entry.nlink--;
+      entry.ctimeMs = Date.now();
+      entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
+      this.releaseNode(entry);
+    }
+    this.changed(location.parent);
+  }
+  async rename(source, destination, options = {}) {
+    options.signal?.throwIfAborted();
+    try {
+      const origin = this.entry(source, "rename");
+      const target = this.entry(destination, "rename", true);
+      const node = origin.node;
+      if (this.terminalDot(source) || this.terminalDot(destination)) this.fail("EINVAL", "rename", source, destination);
+      if (node === this.root || target.node === this.root) this.fail("EBUSY", "rename", source, destination);
+      if (destination.endsWith("/") && node.type !== "directory") this.fail("ENOTDIR", "rename", source, destination);
+      if (options.noReplace && target.node) this.fail("EEXIST", "rename", source, destination);
+      if (target.node === node) return;
+      if (node.type === "directory" && target.path.startsWith(`${origin.path}/`)) this.fail("EINVAL", "rename", source, destination);
+      this.permission(origin.parent, 3, "rename", source);
+      this.permission(target.parent, 3, "rename", destination);
+      if (target.node) {
+        if (node.type === "directory" && target.node.type !== "directory") this.fail("ENOTDIR", "rename", source, destination);
+        if (node.type !== "directory" && target.node.type === "directory") this.fail("EISDIR", "rename", source, destination);
+        if (target.node.type === "directory" && target.node.entries.size > 0) this.fail("ENOTEMPTY", "rename", source, destination);
+      }
+      const nameGrowth = target.node ? 0 : (target.name.length - origin.name.length) * 2;
+      this.ledger.reserve(Math.max(0, nameGrowth), 0, "rename", source);
+      try {
+        target.parent.entries.set(target.name, node);
+      } catch (error) {
+        this.ledger.release(Math.max(0, nameGrowth), 0);
+        throw error;
+      }
+      origin.parent.entries.delete(origin.name);
+      if (target.node) {
+        this.ledger.release(origin.name.length * 2, 1);
+        target.node.nlink--;
+        target.node.ctimeMs = Date.now();
+        target.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, target.node.revision + 1);
+        this.releaseNode(target.node);
+      } else if (nameGrowth < 0) this.ledger.release(-nameGrowth, 0);
+      this.changed(origin.parent);
+      this.changed(target.parent);
+      node.ctimeMs = Date.now();
+      node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    } catch (error) {
+      if (error instanceof FsError) throw new FsError(error.code, { syscall: "rename", path: source, dest: destination, cause: error });
+      throw error;
+    }
+  }
+  async copyFile(source, destination, options = {}) {
+    options.signal?.throwIfAborted();
+    try {
+      const origin = this.file(source, "copyFile");
+      this.permission(origin, 4, "copyFile", source);
+      const target = this.resolve(destination, "copyFile", { followFinal: !options.exclusive, allowMissing: true });
+      if (target.node && options.exclusive) this.fail("EEXIST", "copyFile", source, destination);
+      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 });
+      throw error;
+    }
+  }
+  async realpath(path, options = {}) {
+    options.signal?.throwIfAborted();
+    return this.resolve(path, "realpath").path;
+  }
+  async access(path, mode2 = 0, options = {}) {
+    options.signal?.throwIfAborted();
+    if (!Number.isInteger(mode2) || mode2 < 0 || mode2 > 7) this.fail("EINVAL", "access", path);
+    this.permission(this.resolve(path, "access").node, mode2, "access", path);
+  }
+  async readlink(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const node = this.resolve(path, "readlink", { followFinal: false }).node;
+    if (node.type !== "symlink") this.fail("EINVAL", "readlink", path);
+    return node.target;
+  }
+  async symlink(target, path, options = {}) {
+    options.signal?.throwIfAborted();
+    this.validatePath(target, "symlink");
+    const location = this.resolve(path, "symlink", { followFinal: false, allowMissing: true });
+    if (location.node) this.fail("EEXIST", "symlink", path);
+    this.permission(location.parent, 3, "symlink", path);
+    this.addNode(location.parent, location.name, () => ({
+      ...this.metadata(typeModes.symlink | 511),
+      type: "symlink",
+      target
+    }), "symlink", path, target.length * 2);
+  }
+  async link(existingPath, newPath, options = {}) {
+    options.signal?.throwIfAborted();
+    const node = this.resolve(existingPath, "link", { followFinal: false }).node;
+    if (node.type === "directory") this.fail("EPERM", "link", existingPath, newPath);
+    const target = this.resolve(newPath, "link", { followFinal: false, allowMissing: true });
+    if (target.node) this.fail("EEXIST", "link", existingPath, newPath);
+    this.permission(target.parent, 3, "link", newPath);
+    this.ledger.reserve(target.name.length * 2, 1, "link", newPath);
+    try {
+      target.parent.entries.set(target.name, node);
+    } catch (error) {
+      this.ledger.release(target.name.length * 2, 1);
+      throw error;
+    }
+    node.nlink++;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    this.changed(target.parent);
+  }
+  async chmod(path, mode2, options = {}) {
+    options.signal?.throwIfAborted();
+    const permissions = this.mode(mode2, 0, "chmod", path);
+    const node = this.resolve(path, "chmod").node;
+    node.mode = typeModes[node.type] | permissions;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+  }
+  async utimes(path, atimeMs, mtimeMs, options = {}) {
+    options.signal?.throwIfAborted();
+    if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs)) this.fail("EINVAL", "utimes", path);
+    const node = this.resolve(path, "utimes").node;
+    node.atimeMs = atimeMs;
+    node.mtimeMs = mtimeMs;
+    node.ctimeMs = Date.now();
+    node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+  }
+  async truncate(path, length = 0, options = {}) {
+    options.signal?.throwIfAborted();
+    this.integer(length, "truncate", path);
+    const node = this.file(path, "truncate");
+    this.permission(node, 2, "truncate", path);
+    this.resizeNode(node, length, "truncate", path);
+  }
+  resizeNode(node, length, syscall, path) {
+    const data = this.allocate(length, syscall, path);
+    try {
+      data.data.set(node.data.subarray(0, length));
+    } catch (error) {
+      data.release();
+      throw error;
+    }
+    this.replaceData(node, data);
+    this.changed(node);
+  }
+  async openResizeFile(path, options = {}) {
+    options.signal?.throwIfAborted();
+    if (!stockRetainedResize(this)) throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+    const location = this.resolve(path, "openResizeFile", { allowMissing: options.create === true, resizeCreate: options.create ?? false });
+    let mode2 = 438;
+    if (location.node) {
+      if (location.node.type !== "file") this.fail("EISDIR", "openResizeFile", path);
+      this.permission(location.node, 2, "openResizeFile", path);
+    } else {
+      this.permission(location.parent, 3, "openResizeFile", path);
+      mode2 = this.mode(options.mode, mode2, "openResizeFile", path);
+    }
+    this.ledger.reserve(path.length * 2, 1, "openResizeFile", path);
+    let node;
+    try {
+      node = this.openWrite(path, {}, "openResizeFile", { location, mode: mode2, append: false });
+      node.references++;
+    } catch (error) {
+      this.ledger.release(path.length * 2, 1);
+      throw error;
+    }
+    const snapshot = this.snapshot.bind(this);
+    const integer2 = this.integer.bind(this);
+    const resizeNode = this.resizeNode.bind(this);
+    const releaseReference = this.releaseReference.bind(this);
+    let closing;
+    const current = (signal, syscall) => {
+      signal?.throwIfAborted();
+      if (!node) throw new FsError("EBADF", { syscall, path });
+      return node;
+    };
+    return {
+      async stat(options2 = {}) {
+        return snapshot(current(options2.signal, "fstat"));
+      },
+      async seekEnd(options2 = {}) {
+        return BigInt(current(options2.signal, "lseek").data.byteLength);
+      },
+      async truncate(length, options2 = {}) {
+        const file = current(options2.signal, "ftruncate");
+        integer2(length, "ftruncate", path);
+        resizeNode(file, length, "ftruncate", path);
+      },
+      close() {
+        if (!closing) {
+          const retained = node;
+          node = void 0;
+          closing = Promise.resolve().then(() => {
+            if (retained) releaseReference(retained, path);
+          });
+        }
+        return closing;
+      }
+    };
+  }
+  async openReadFile(path, options = {}) {
+    const signal = options.signal;
+    signal?.throwIfAborted();
+    const allowDirectory = options.allowDirectory === true;
+    signal?.throwIfAborted();
+    const unsupported2 = () => {
+      throw new FsError("ENOTSUP", { syscall: "openReadFile", path });
+    };
+    const owner = ownedStores.get(this);
+    if (!owner || Object.getPrototypeOf(this) !== _MemoryFileSystem.prototype || Object.getOwnPropertyDescriptor(this, "root")?.value !== owner.root || Object.getOwnPropertyDescriptor(this, "ledger")?.value !== owner.ledger) unsupported2();
+    for (const name of [
+      "openReadFile",
+      "readFile",
+      "readStream",
+      "stat",
+      "lstat",
+      "realpath",
+      "access",
+      "file",
+      "resolve",
+      "permission",
+      "validatePath",
+      "fail",
+      "snapshot",
+      "integer",
+      "releaseReference",
+      "releaseNode"
+    ]) {
+      const descriptor = Object.getOwnPropertyDescriptor(this, name) ?? Object.getOwnPropertyDescriptor(_MemoryFileSystem.prototype, name);
+      if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value) unsupported2();
+    }
+    const retainedRead = Object.getOwnPropertyDescriptor(this, "capabilities")?.value?.retainedRead;
+    signal?.throwIfAborted();
+    if (retainedRead !== true) unsupported2();
+    const selected = allowDirectory ? this.resolve(path, "openReadFile").node : this.file(path, "openReadFile");
+    if (selected.type !== "file" && selected.type !== "directory") this.fail("EISDIR", "openReadFile", path);
+    let node = selected;
+    this.permission(node, 4, "openReadFile", path);
+    signal?.throwIfAborted();
+    this.ledger.reserve(path.length * 2, 1, "openReadFile", path);
+    node.references++;
+    const snapshot = this.snapshot.bind(this);
+    const integer2 = this.integer.bind(this);
+    const releaseReference = this.releaseReference.bind(this);
+    let closing;
+    const current = (signal2, syscall) => {
+      signal2?.throwIfAborted();
+      if (!node) throw new FsError("EBADF", { syscall, path });
+      return node;
+    };
+    return {
+      async stat(options2 = {}) {
+        return snapshot(current(options2.signal, "fstat"));
+      },
+      async seekEnd(options2 = {}) {
+        const file = current(options2.signal, "lseek");
+        return file.type === "directory" ? ext4HtreeEof64 : BigInt(file.data.byteLength);
+      },
+      async read(position, maxBytes, options2 = {}) {
+        const file = current(options2.signal, "read");
+        integer2(position, "read", path);
+        integer2(maxBytes, "read", path);
+        if (maxBytes === 0 || maxBytes > Number.MAX_SAFE_INTEGER - position) {
+          throw new FsError("EINVAL", { syscall: "read", path });
+        }
+        if (file.type === "directory") throw new FsError("EISDIR", { syscall: "read", path });
+        const bytes = file.data.slice(position, position + maxBytes);
+        file.atimeMs = Date.now();
+        return bytes;
+      },
+      close() {
+        if (node) {
+          releaseReference(node, path);
+          node = void 0;
+        }
+        closing ??= Promise.resolve();
+        return closing;
+      }
+    };
+  }
+  async *readStream(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const start = options.start ?? 0;
+    const chunkSize2 = options.chunkSize ?? 64 * 1024;
+    this.integer(start, "readStream", path);
+    this.integer(chunkSize2, "readStream", path);
+    if (chunkSize2 === 0) this.fail("EINVAL", "readStream", path);
+    if (options.endExclusive !== void 0) {
+      this.integer(options.endExclusive, "readStream", path);
+      if (options.endExclusive < start) this.fail("EINVAL", "readStream", path);
+    }
+    const node = this.file(path, "readStream");
+    this.permission(node, 4, "readStream", path);
+    this.ledger.reserve(path.length * 2, 1, "readStream", path);
+    node.references++;
+    const allocation = node.allocation;
+    allocation.retain();
+    const data = node.data;
+    try {
+      const end = Math.min(options.endExclusive ?? data.byteLength, data.byteLength);
+      node.atimeMs = Date.now();
+      for (let offset = start; offset < end; offset += chunkSize2) {
+        options.signal?.throwIfAborted();
+        yield data.slice(offset, Math.min(offset + chunkSize2, end));
+      }
+      options.signal?.throwIfAborted();
+    } finally {
+      allocation.release();
+      this.releaseReference(node, path);
+    }
+  }
+  async writeStream(path, source, options = {}) {
+    options.signal?.throwIfAborted();
+    this.validatePath(path, "writeStream");
+    this.ledger.reserve(path.length * 2, 1, "writeStream", path);
+    let node;
+    try {
+      node = this.openWrite(path, options, "writeStream");
+      node.references++;
+      const append = options.flag === "a" || options.flag === "ax";
+      let position = 0;
+      if (!append) {
+        this.replaceData(node, new MemoryAllocation(new Uint8Array(), this.ledger));
+        this.changed(node);
+      }
+      for await (const chunk of source) {
+        options.signal?.throwIfAborted();
+        if (!(chunk instanceof Uint8Array)) throw new TypeError("Memory files require Uint8Array data");
+        this.writeAt(node, chunk, append ? node.data.byteLength : position, "writeStream", path);
+        if (!append) position += chunk.byteLength;
+      }
+      options.signal?.throwIfAborted();
+    } finally {
+      if (node) this.releaseReference(node, path);
+      else this.ledger.release(path.length * 2, 1);
+    }
+  }
+};
+var memoryImplementation = Object.getOwnPropertyDescriptors(MemoryFileSystem.prototype);
+function stockDescriptorWrite(filesystem) {
+  if (Object.getPrototypeOf(filesystem) !== MemoryFileSystem.prototype) return false;
+  const owner = ownedStores.get(filesystem);
+  if (!owner || Object.getOwnPropertyDescriptor(filesystem, "root")?.value !== owner.root || Object.getOwnPropertyDescriptor(filesystem, "capabilities")?.value !== owner.capabilities) return false;
+  for (const name of [
+    "writeStream",
+    "writeFile",
+    "appendFile",
+    "access",
+    "stat",
+    "lstat",
+    "realpath",
+    "openWrite",
+    "prepareWrite",
+    "writeData",
+    "addNode",
+    "replaceData",
+    "releaseReference",
+    "releaseNode",
+    "resolve",
+    "permission",
+    "validatePath",
+    "mode",
+    "bytes",
+    "allocate",
+    "changed",
+    "metadata",
+    "integer",
+    "writeAt",
+    "fail"
+  ]) {
+    const descriptor = Object.getOwnPropertyDescriptor(filesystem, name) ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
+    if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value) return false;
+  }
+  return true;
+}
+function stockRetainedResize(filesystem) {
+  if (!stockDescriptorWrite(filesystem)) return false;
+  const owner = ownedStores.get(filesystem);
+  if (!owner || Object.getOwnPropertyDescriptor(filesystem, "ledger")?.value !== owner.ledger) return false;
+  for (const name of ["openResizeFile", "truncate", "resizeNode", "snapshot"]) {
+    const descriptor = Object.getOwnPropertyDescriptor(filesystem, name) ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
+    if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value) return false;
+  }
+  return true;
+}
+var deviceCapabilities = Object.freeze({
+  readOnly: false,
+  read: true,
+  stat: true,
+  realpath: true,
+  access: true,
+  readdir: false,
+  write: true,
+  append: true,
+  exclusiveCreate: true,
+  streamingRead: true,
+  retainedRead: true,
+  streamingWrite: true,
+  streamingAppend: true,
+  copy: true,
+  exclusiveCopy: true,
+  remove: false,
+  removeDirectory: false,
+  recursiveRemove: false,
+  rename: false,
+  mkdir: false,
+  recursiveMkdir: false,
+  symlinks: false,
+  hardlinks: false,
+  readlink: false,
+  permissions: false,
+  timestamps: false,
+  truncate: false,
+  randomAccessWrite: false,
+  atomicFileMutation: false,
+  atomicFileStaging: false,
+  atomicDirectoryMetadata: false,
+  atomicRename: false,
+  atomicRenameNoReplace: false,
+  descriptorWriteStream: true,
+  retainedResize: true,
+  atomicResize: false
+});
+var syntheticStat = Object.freeze({
+  type: "directory",
+  size: 0,
+  mode: 16749,
+  mtimeMs: 0,
+  atimeMs: 0,
+  ctimeMs: 0
+});
+function composeAbortSignals(signals) {
+  const controller = new AbortController();
+  const listeners = /* @__PURE__ */ new Map();
+  const dispose = () => {
+    for (const [signal, listener] of listeners) signal.removeEventListener("abort", listener);
+    listeners.clear();
+  };
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return { signal: controller.signal, dispose };
+    }
+  }
+  try {
+    for (const signal of new Set(signals)) {
+      const listener = () => {
+        dispose();
+        controller.abort(signal.reason);
+      };
+      listeners.set(signal, listener);
+      signal.addEventListener("abort", listener, { once: true });
+      if (signal.aborted) listener();
+      if (controller.signal.aborted) break;
+    }
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+  return { signal: controller.signal, dispose };
+}
+var XmlLimitError = class extends SyntaxError {
+  constructor(limit, message) {
+    super(message);
+    this.limit = limit;
+  }
+  limit;
+};
+function* find(source, needle, start) {
+  let work = 0;
+  for (let offset = start; offset < source.length; offset++) {
+    if (source.startsWith(needle, offset)) {
+      if (work) yield work;
+      return offset;
+    }
+    if (++work === 512) {
+      yield work;
+      work = 0;
+    }
+  }
+  if (work) yield work;
+  return -1;
+}
+var xmlNamespace = "http://www.w3.org/XML/1998/namespace";
+var xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
+function invalid(message) {
+  throw new SyntaxError(`Invalid XML: ${message}`);
+}
+function validCharacter(point) {
+  return point === 9 || point === 10 || point === 13 || point >= 32 && point <= 55295 || point >= 57344 && point <= 65533 || point >= 65536 && point <= 1114111;
+}
+function nameStart(point) {
+  return point === 95 || point >= 65 && point <= 90 || point >= 97 && point <= 122 || point >= 192 && point <= 214 || point >= 216 && point <= 246 || point >= 248 && point <= 767 || point >= 880 && point <= 893 || point >= 895 && point <= 8191 || point >= 8204 && point <= 8205 || point >= 8304 && point <= 8591 || point >= 11264 && point <= 12271 || point >= 12289 && point <= 55295 || point >= 63744 && point <= 64975 || point >= 65008 && point <= 65533 || point >= 65536 && point <= 983039;
+}
+function namePart(point) {
+  return nameStart(point) || point === 45 || point === 46 || point === 183 || point >= 48 && point <= 57 || point >= 768 && point <= 879 || point >= 8255 && point <= 8256;
+}
+function* qualifiedName(name) {
+  let prefix = "";
+  let start = 0;
+  let first = true;
+  let work = 0;
+  for (let offset = 0; offset < name.length; ) {
+    const point = name.codePointAt(offset);
+    if (point === 58) {
+      if (start !== 0 || first) invalid("invalid qualified name");
+      prefix = name.slice(0, offset);
+      start = offset + 1;
+      first = true;
+    } else {
+      if (!(first ? nameStart(point) : namePart(point))) invalid("invalid qualified name");
+      first = false;
+    }
+    const width = point > 65535 ? 2 : 1;
+    offset += width;
+    work += width;
+    if (work >= 512) {
+      yield work;
+      work = 0;
+    }
+  }
+  if (first) invalid("invalid qualified name");
+  if (work) yield work;
+  return [prefix, name.slice(start)];
+}
+function* entities(text) {
+  let result = "";
+  let offset = 0;
+  while (offset < text.length) {
+    const start = yield* find(text, "&", offset);
+    if (start < 0) return result + text.slice(offset);
+    result += text.slice(offset, start);
+    const end = yield* find(text, ";", start + 1);
+    if (end < 0) invalid("unterminated entity");
+    const entity = text.slice(start + 1, end);
+    const predefined = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+    if (Object.hasOwn(predefined, entity)) result += predefined[entity];
+    else {
+      const hexadecimal = entity.startsWith("#x");
+      const digits = entity.slice(hexadecimal ? 2 : 1);
+      if (!entity.startsWith("#") || !digits.length) invalid("undeclared entity");
+      let point = 0;
+      for (let index = 0; index < digits.length; index++) {
+        const code = digits.charCodeAt(index);
+        const digit = code >= 48 && code <= 57 ? code - 48 : hexadecimal && code >= 65 && code <= 70 ? code - 55 : hexadecimal && code >= 97 && code <= 102 ? code - 87 : -1;
+        if (digit < 0) invalid("undeclared entity");
+        point = point * (hexadecimal ? 16 : 10) + digit;
+        if (point > 1114111) invalid("invalid character reference");
+        if ((index + 1) % 512 === 0) yield 512;
+      }
+      if (digits.length % 512) yield digits.length % 512;
+      if (!validCharacter(point)) invalid("invalid character reference");
+      result += String.fromCodePoint(point);
+    }
+    offset = end + 1;
+  }
+  return result;
+}
+function* validDeclaration(content, expectedEncoding) {
+  let offset = 0;
+  const whitespace = function* () {
+    const start = offset;
+    while (offset < content.length && " 	\n\r".includes(content[offset])) {
+      offset++;
+      if ((offset - start) % 512 === 0) yield 512;
+    }
+    if ((offset - start) % 512) yield (offset - start) % 512;
+    return offset - start;
+  };
+  const field = function* (name) {
+    if (content.slice(offset, offset + name.length).toLowerCase() !== name) return void 0;
+    offset += name.length;
+    yield name.length;
+    yield* whitespace();
+    if (content[offset++] !== "=") return void 0;
+    yield* whitespace();
+    const quote = content[offset++];
+    if (quote !== "'" && quote !== '"') return void 0;
+    const start = offset;
+    while (offset < content.length && content[offset] !== quote) {
+      offset++;
+      if ((offset - start) % 512 === 0) yield 512;
+    }
+    if ((offset - start) % 512) yield (offset - start) % 512;
+    if (offset >= content.length) return void 0;
+    return content.slice(start, offset++);
+  };
+  if (!(yield* whitespace()) || (yield* field("version")) !== "1.0") return false;
+  let spacing = yield* whitespace();
+  if (content.slice(offset, offset + 8).toLowerCase() === "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;
+    spacing = yield* whitespace();
+  }
+  if (content.slice(offset, offset + 10).toLowerCase() === "standalone") {
+    if (!spacing) return false;
+    const standalone = yield* field("standalone");
+    if (standalone === void 0 || standalone.length > 3 || !["yes", "no"].includes(standalone.toLowerCase())) return false;
+    yield* whitespace();
+  }
+  return offset === content.length;
+}
+function* parseXmlSteps(input, limits = {}) {
+  const maxDepth = limits.maxDepth ?? 64;
+  const maxNodes = limits.maxNodes ?? 1e5;
+  const maxAttributes = limits.maxAttributes ?? 1e4;
+  const retainContent = limits.retainContent !== false;
+  const maxContentNodes = limits.maxContentNodes ?? (retainContent ? 1e5 : maxNodes);
+  const emptyContent = Object.freeze([]);
+  const emptyAttributes = Object.freeze([]);
+  const emptyNamespaces = /* @__PURE__ */ new Map();
+  const maxAttributesPerElement = limits.maxAttributesPerElement ?? 128;
+  const maxNamespaces = limits.maxNamespaces ?? 256;
+  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 chunks = [];
+  let chunk = "";
+  for (let index = input.charCodeAt(0) === 65279 ? 1 : 0; index < input.length; index++) {
+    const point = input.codePointAt(index);
+    if (!validCharacter(point)) invalid("invalid character");
+    if (point === 13) {
+      chunk += "\n";
+      if (input.charCodeAt(index + 1) === 10) index++;
+    } else {
+      chunk += String.fromCodePoint(point);
+      if (point > 65535) index++;
+    }
+    if (chunk.length >= 512) {
+      chunks.push(chunk);
+      chunk = "";
+      yield 512;
+    }
+  }
+  chunks.push(chunk);
+  if (chunk.length) yield chunk.length;
+  const source = chunks.join("");
+  const stack = [];
+  let root;
+  let declaration;
+  let offset = 0;
+  let nodes = 0;
+  let attributeCount = 0;
+  let contentNodes = 0;
+  const admitContent = () => {
+    if (++contentNodes > maxContentNodes) throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
+  };
+  const whitespace = function* () {
+    let work = 0;
+    while (offset < source.length && " 	\n\r".includes(source[offset])) {
+      offset++;
+      if (++work === 512) {
+        yield work;
+        work = 0;
+      }
+    }
+    if (work) yield work;
+  };
+  const readName = function* () {
+    const start = offset;
+    while (offset < source.length && !" 	\r\n/=>?".includes(source[offset])) {
+      offset++;
+      if ((offset - start) % 512 === 0) yield 512;
+    }
+    if ((offset - start) % 512) yield (offset - start) % 512;
+    const name = source.slice(start, offset);
+    yield* qualifiedName(name);
+    return name;
+  };
+  const appendText = function* (text, kind = "text") {
+    const parent = stack.at(-1);
+    if (parent) {
+      parent.element.text += text;
+      if (retainContent && (text.length || kind === "cdata")) {
+        admitContent();
+        parent.content.push({ kind, text });
+      }
+    } else {
+      for (let index = 0; index < text.length; index++) {
+        if (!" 	\r\n".includes(text[index])) invalid("text outside the root");
+        if ((index + 1) % 512 === 0) yield 512;
+      }
+      if (text.length % 512) yield text.length % 512;
+    }
+  };
+  while (offset < source.length) {
+    yield 1;
+    if (source[offset] !== "<") {
+      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));
+      offset += text.length;
+    } else if (source.startsWith("<!--", offset)) {
+      const end = yield* find(source, "-->", offset + 4);
+      if (end < 0 || (yield* find(source.slice(offset + 4, end), "--", 0)) >= 0 || source.slice(offset + 4, end).endsWith("-")) {
+        invalid("malformed comment");
+      }
+      const parent = stack.at(-1);
+      if (retainContent && parent) {
+        admitContent();
+        parent.content.push({ kind: "comment", text: source.slice(offset + 4, end) });
+      }
+      offset = end + 3;
+    } else if (source.startsWith("<![CDATA[", offset)) {
+      if (!stack.length) invalid("CDATA outside root");
+      const end = yield* find(source, "]]>", offset + 9);
+      if (end < 0) invalid("unterminated CDATA");
+      yield* appendText(source.slice(offset + 9, end), "cdata");
+      offset = end + 3;
+    } else if (source.startsWith("<?", offset)) {
+      const start = offset;
+      offset += 2;
+      const target = yield* readName();
+      const end = yield* find(source, "?>", offset);
+      if (end < 0) invalid("unterminated processing instruction");
+      const content = source.slice(offset, end);
+      if (target.length === 3 && target.toLowerCase() === "xml") {
+        if (start !== 0 || target !== "xml" || !(yield* validDeclaration(content, limits.expectedEncoding))) {
+          invalid("unsupported XML declaration");
+        }
+        if (retainContent) declaration = source.slice(start, end + 2);
+      } 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;
+          admitContent();
+          parent.content.push({ kind: "processing-instruction", target, text: content.slice(start2) });
+        }
+      }
+      offset = end + 2;
+    } else if (source.startsWith("<!", offset)) {
+      invalid("DTD and entity declarations are forbidden");
+    } else if (source.startsWith("</", offset)) {
+      offset += 2;
+      const name = yield* readName();
+      yield* whitespace();
+      if (source[offset++] !== ">" || stack.pop()?.name !== name) invalid("mismatched closing tag");
+    } else {
+      offset++;
+      const name = yield* readName();
+      const attributes = /* @__PURE__ */ new Map();
+      let namespaces = stack.at(-1)?.namespaces ?? /* @__PURE__ */ new Map([["xml", xmlNamespace]]);
+      let ownsNamespaces = stack.length === 0;
+      while (true) {
+        const beforeSpace = offset;
+        yield* whitespace();
+        if (source[offset] === "/" || source[offset] === ">") break;
+        if (offset === beforeSpace) invalid("attributes require whitespace");
+        const attribute = yield* readName();
+        if (attributes.has(attribute)) invalid("duplicate attribute");
+        if (++attributeCount > maxAttributes) throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
+        if (attributes.size >= maxAttributesPerElement) throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
+        yield* whitespace();
+        if (source[offset++] !== "=") invalid("missing attribute equals");
+        yield* whitespace();
+        const quote = source[offset++];
+        if (quote !== '"' && quote !== "'") invalid("unquoted attribute");
+        const end = yield* find(source, quote, offset);
+        if (end < 0) invalid("unterminated attribute");
+        const raw = source.slice(offset, end);
+        if ((yield* find(raw, "<", 0)) >= 0) invalid("less-than in attribute");
+        let normalized = "";
+        for (let index = 0; index < raw.length; index++) {
+          const character = raw[index];
+          normalized += character === "	" || character === "\n" || character === "\r" ? " " : character;
+          if ((index + 1) % 512 === 0) yield 512;
+        }
+        if (raw.length % 512) yield raw.length % 512;
+        const value = yield* entities(normalized);
+        attributes.set(attribute, value);
+        offset = end + 1;
+        if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
+          const prefix2 = attribute === "xmlns" ? "" : attribute.slice(6);
+          if (prefix2 === "xmlns" || value === xmlnsNamespace || prefix2 === "xml" !== (value === xmlNamespace) || prefix2 !== "" && value === "") invalid("invalid namespace binding");
+          if (!ownsNamespaces) {
+            const copy = /* @__PURE__ */ new Map();
+            for (const [key, uri] of namespaces) {
+              copy.set(key, uri);
+              yield 1;
+            }
+            namespaces = copy;
+            ownsNamespaces = true;
+          }
+          namespaces.set(prefix2, value);
+          if (namespaces.size > maxNamespaces) throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
+        }
+      }
+      const expanded = /* @__PURE__ */ new Set();
+      for (const attribute of attributes.keys()) {
+        if (attribute === "xmlns" || attribute.startsWith("xmlns:")) continue;
+        const [prefix2, localName2] = yield* qualifiedName(attribute);
+        if (prefix2 && !namespaces.has(prefix2)) invalid("unbound attribute prefix");
+        const key = JSON.stringify([prefix2 ? namespaces.get(prefix2) : "", localName2]);
+        if (expanded.has(key)) invalid("duplicate expanded attribute");
+        expanded.add(key);
+      }
+      const [prefix, localName] = yield* qualifiedName(name);
+      if (prefix === "xmlns" || prefix && !namespaces.has(prefix)) invalid("unbound element prefix");
+      if (++nodes > maxNodes) throw new XmlLimitError("maxNodes", "XML resource limit exceeded");
+      if (stack.length + 1 > maxDepth) throw new XmlLimitError("maxDepth", "XML resource limit exceeded");
+      const namespace = namespaces.get(prefix) ?? "";
+      limits.onElement?.({ name, namespace, localName }, stack.at(-1)?.element, stack.length + 1);
+      admitContent();
+      const retainedAttributes = [];
+      for (const [attribute, value] of retainContent ? attributes : []) {
+        const [prefix2, localName2] = yield* qualifiedName(attribute);
+        admitContent();
+        retainedAttributes.push({
+          name: attribute,
+          localName: localName2,
+          namespace: attribute === "xmlns" || prefix2 === "xmlns" ? xmlnsNamespace : prefix2 ? namespaces.get(prefix2) : "",
+          value
+        });
+        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 parent = stack.at(-1);
+      if (parent) {
+        parent.element.children.push(element);
+        parent.content?.push(element);
+      } else if (root) invalid("multiple root elements");
+      else root = element;
+      const empty = source[offset] === "/";
+      if (empty) offset++;
+      if (source[offset++] !== ">") invalid("unterminated start tag");
+      if (!empty) stack.push({ element, content, name, namespaces });
+    }
+  }
+  if (stack.length || !root) invalid("incomplete document");
+  return root;
+}
+function parseXml(input, limits = {}) {
+  const parser = parseXmlSteps(input, limits);
+  let result = parser.next();
+  while (!result.done) result = parser.next();
+  return result.value;
+}
+var XmlResponseLimitError = class extends SyntaxError {
+};
+function invalid2(message) {
+  throw new SyntaxError(`Invalid WebDAV XML: ${message}`);
+}
+function parseXml2(input, limits = {}) {
+  const { maxResponses, ...documentLimits } = limits;
+  if (maxResponses !== void 0 && (!Number.isSafeInteger(maxResponses) || maxResponses < 1)) {
+    throw new RangeError("XML limits must be positive integers");
+  }
+  let responses2 = 0;
+  try {
+    return parseXml(input, {
+      ...documentLimits,
+      retainContent: false,
+      onElement(element, parent, depth) {
+        if (maxResponses !== void 0 && depth === 2 && parent?.namespace === "DAV:" && parent.localName === "multistatus" && element.namespace === "DAV:" && element.localName === "response" && ++responses2 > maxResponses) {
+          throw new XmlResponseLimitError("WebDAV XML response limit exceeded");
+        }
+      }
+    });
+  } catch (error) {
+    if (error instanceof XmlLimitError) invalid2(error.message);
+    if (error instanceof SyntaxError && error.message.startsWith("Invalid XML:")) {
+      error.message = error.message.replace("Invalid XML:", "Invalid WebDAV XML:");
+    }
+    throw error;
+  }
+}
+function davChildren(element, localName) {
+  return element.children.filter((child) => child.namespace === "DAV:" && child.localName === localName);
+}
+function davChild(element, localName) {
+  const children = davChildren(element, localName);
+  if (children.length > 1) invalid2(`duplicate DAV:${localName}`);
+  return children[0];
+}
+function scalar(element) {
+  if (element.children.length) invalid2("expected text-only element");
+  return element.text.trim();
+}
+var timestampNamespace = "urn:virtual-bash:metadata";
+var propfindBody = `<?xml version="1.0" encoding="utf-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/><d:getcontentlength/><d:getlastmodified/><d:creationdate/><d:getetag/><v:timestamps xmlns:v="${timestampNamespace}"/></d:prop></d:propfind>`;
+var lockBody = '<d:lockinfo xmlns:d="DAV:"><d:lockscope><d:exclusive/></d:lockscope><d:locktype><d:write/></d:locktype></d:lockinfo>';
+var resourceIdBody = '<?xml version="1.0" encoding="utf-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:resource-id/></d:prop></d:propfind>';
+function fail3(code, syscall, path, message) {
+  throw new FsError(code, { syscall, path, ...message === void 0 ? {} : { message } });
+}
+function positive(value, name, zero = false) {
+  if (!Number.isSafeInteger(value) || value < (zero ? 0 : 1)) {
+    throw new FsError("EINVAL", { message: `${name} must be a ${zero ? "nonnegative" : "positive"} safe integer` });
+  }
+  return value;
+}
+function createRequestTimeout(timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort(new DOMException("The operation was aborted due to timeout", "TimeoutError"));
+  }, timeoutMs);
+  if (typeof timer === "object" && timer !== null) {
+    const handle = timer;
+    handle.unref?.();
+  }
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer);
+    }
+  };
+}
+function nativeRequestStreamsSupported(url) {
+  let body;
+  try {
+    body = new ReadableStream({ start(destination) {
+      destination.close();
+    } });
+    let duplexAccessed = false;
+    const init = {
+      method: "PUT",
+      body,
+      get duplex() {
+        duplexAccessed = true;
+        return "half";
+      }
+    };
+    const request = new Request(url, init);
+    return duplexAccessed && !request.headers.has("Content-Type");
+  } catch {
+    return false;
+  } finally {
+    if (body && !body.locked) void body.cancel().catch(() => {
+    });
+  }
+}
+function strongEtag(value, path) {
+  if (!value || !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(value)) {
+    fail3("ENOTSUP", "webdav", path, "operation requires a strong entity tag");
+  }
+  return value;
+}
+function normalize(path) {
+  if (typeof path !== "string" || path.includes("\0") || path.includes("\\")) {
+    fail3("EINVAL", "resolve", String(path), "invalid WebDAV path");
+  }
+  try {
+    encodeURIComponent(path);
+  } catch {
+    fail3("EINVAL", "resolve", path, "path contains an unpaired surrogate");
+  }
+  const segments = [];
+  for (const segment of path.split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") {
+      if (!segments.length) fail3("EACCES", "resolve", path, "path escapes WebDAV root");
+      segments.pop();
+    } else segments.push(segment);
+  }
+  return `/${segments.join("/")}`;
+}
+function validateDirectoryWalkPath(path, syscall = "access") {
+  if (typeof path !== "string") fail3("EINVAL", "resolve", String(path), "invalid WebDAV path");
+  let bytes = 0;
+  let components2 = 0;
+  let inComponent = false;
+  for (let offset = 0; offset < path.length; offset++) {
+    const point = path.codePointAt(offset);
+    if (point === 47) inComponent = false;
+    else if (!inComponent) {
+      components2++;
+      inComponent = true;
+    }
+    bytes += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+    if (point > 65535) offset++;
+    if (bytes > 65536 || components2 > 256) {
+      fail3("ENAMETOOLONG", syscall, path, "directory access exceeds the 64KiB path or 256 component limit");
+    }
+  }
+}
+function requiresCollection(path) {
+  const last = path.split("/").at(-1);
+  return last === "" || last === "." || last === "..";
+}
+function validateUrlText(text) {
+  if (/[\u0000-\u0020\u007f\\?#]/.test(text)) throw new Error("invalid URL characters");
+  for (const segment of text.split("/")) {
+    const decoded = decodeURIComponent(segment);
+    if (decoded === "." || decoded === ".." || /[/\\\u0000]/.test(decoded)) {
+      throw new Error("ambiguous URL segment");
+    }
+  }
+}
+function urlSegments(url) {
+  const pathname = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+  const segments = pathname.slice(1).split("/");
+  if (segments.length === 1 && segments[0] === "") return [];
+  if (segments.some((segment) => segment === "")) throw new Error("empty URL segment");
+  return segments.map((segment) => decodeURIComponent(segment));
+}
+function statusCode(element) {
+  const text = scalar(element);
+  if (!/^HTTP\/\d+\.\d+ [2-5]\d\d(?:[ \t].*)?$/.test(text)) throw new Error("invalid DAV status line");
+  return Number(text.split(" ")[1]);
+}
+var WebDavFileSystem = class {
+  capabilities = Object.freeze({
+    read: true,
+    stat: true,
+    readdir: true,
+    realpath: true,
+    access: true,
+    write: true,
+    append: true,
+    exclusiveCreate: true,
+    explicitDirectories: true,
+    implicitDirectories: false,
+    mkdir: true,
+    recursiveMkdir: true,
+    remove: true,
+    recursiveRemove: true,
+    rename: true,
+    atomicRenameNoReplace: false,
+    copy: true,
+    exclusiveCopy: true,
+    readlink: false,
+    truncate: false,
+    randomAccessWrite: false,
+    removeDirectory: false,
+    streamingAppend: false,
+    symlinks: false,
+    hardlinks: false,
+    permissions: false,
+    timestamps: true,
+    atomicRename: false,
+    streamingRead: true,
+    streamingWrite: true
+  });
+  base;
+  baseSegments;
+  transport;
+  requestStreamSupport;
+  headers;
+  maxResponseBytes;
+  maxXmlBytes;
+  maxEntries;
+  timeoutMs;
+  walkDeadlines = /* @__PURE__ */ new WeakMap();
+  overwritePolicy;
+  configuredComparison;
+  atomicEmptyDirectory;
+  etags = /* @__PURE__ */ new WeakMap();
+  constructor(options) {
+    if (typeof options.fetch !== "function") throw new FsError("EINVAL", { message: "an explicit fetch transport is required" });
+    if (options.requestStreamSupport !== void 0 && options.requestStreamSupport !== "native" && typeof options.requestStreamSupport !== "boolean") {
+      throw new FsError("EINVAL", { message: "requestStreamSupport must be native or a boolean" });
+    }
+    if (options.compareEntry !== void 0 && typeof options.compareEntry !== "function") {
+      throw new FsError("EINVAL", { message: "compareEntry must be a function" });
+    }
+    if (options.compareEntry !== void 0) assertCallbackAuthorityAllowed();
+    try {
+      validateUrlText(options.baseUrl);
+      this.base = new URL(options.baseUrl);
+      if (!["http:", "https:"].includes(this.base.protocol) || this.base.username || this.base.password || this.base.search || this.base.hash) throw new Error("invalid base URL");
+      this.baseSegments = urlSegments(this.base);
+      this.base.pathname = `/${this.baseSegments.map(encodeURIComponent).join("/")}${this.baseSegments.length ? "/" : ""}`;
+      this.headers = new Headers(options.headers);
+      for (const name of this.headers.keys()) {
+        if ([
+          "host",
+          "destination",
+          "depth",
+          "overwrite",
+          "if",
+          "if-match",
+          "if-none-match",
+          "range",
+          "content-length",
+          "content-type",
+          "transfer-encoding",
+          "connection",
+          "proxy-authorization",
+          "lock-token",
+          "timeout"
+        ].includes(name)) {
+          throw new Error(`reserved header ${name}`);
+        }
+      }
+      if (this.base.protocol !== "https:" && [...this.headers.keys()].some((name) => name === "authorization" || name === "cookie")) {
+        throw new Error("explicit credentials require HTTPS");
+      }
+    } catch (cause) {
+      throw new FsError("EINVAL", { message: "invalid WebDAV base URL or headers", cause });
+    }
+    const binding = options.atomicEmptyDirectory;
+    if (binding !== void 0) {
+      if (!binding || typeof binding !== "object" || binding.namespaceUrl !== this.base.href || typeof binding.removeEmptyDirectory !== "function") {
+        throw new FsError("EINVAL", { message: "atomicEmptyDirectory must bind the canonical WebDAV namespace and a callback" });
+      }
+      this.atomicEmptyDirectory = Object.freeze({ namespaceUrl: this.base.href, removeEmptyDirectory: binding.removeEmptyDirectory });
+    }
+    this.transport = options.fetch === globalThis.fetch ? options.fetch.bind(globalThis) : options.fetch;
+    this.requestStreamSupport = options.requestStreamSupport ?? (options.fetch === globalThis.fetch ? "native" : false);
+    this.capabilities = Object.freeze({
+      ...this.capabilities,
+      removeDirectory: this.atomicEmptyDirectory !== void 0,
+      streamingAppend: this.requestStreamSupport !== false
+    });
+    this.maxResponseBytes = positive(options.maxResponseBytes ?? 64 * 1024 * 1024, "maxResponseBytes");
+    this.maxXmlBytes = positive(options.maxXmlBytes ?? 2 * 1024 * 1024, "maxXmlBytes");
+    this.maxEntries = positive(options.maxEntries ?? 1e4, "maxEntries");
+    this.timeoutMs = positive(options.timeoutMs ?? 3e4, "timeoutMs");
+    this.overwritePolicy = options.overwritePolicy ?? "lock";
+    this.configuredComparison = options.compareEntry !== void 0;
+    if (!["lock", "etag"].includes(this.overwritePolicy)) throw new FsError("EINVAL", { message: "invalid overwritePolicy" });
+    if (this.timeoutMs > 2147483647) throw new FsError("EINVAL", { message: "timeoutMs exceeds timer range" });
+    registerResourceQuery(this, (path, settings) => this.resourceId(path, settings), originalWebDavComparison, options.compareEntry);
+    registerEntryAuthority(this, compareWebDavResources);
+  }
+  compareEntry(path, peer, peerPath, options = {}) {
+    return compareEntries(this, path, peer, peerPath, options);
+  }
+  async resourceId(input, options) {
+    const path = normalize(input);
+    return this.request("PROPFIND", path, options, {
+      headers: { Depth: "0", "Content-Type": "application/xml; charset=utf-8" },
+      body: resourceIdBody
+    }, async (response, signal) => {
+      if (response.status !== 207) this.httpError(response.status, "PROPFIND", path);
+      const responses2 = await this.multistatus(response, signal, "PROPFIND", path);
+      if (responses2.length !== 1) throw new Error("resource identity requires exactly one DAV:response");
+      const entry = responses2[0];
+      const href = davChild(entry, "href");
+      if (!href) throw new Error("missing resource identity response href");
+      if (this.hrefPath(scalar(href)) !== path) fail3("EACCES", "PROPFIND", path, "resource identity response addresses another resource");
+      const wholeStatus = davChild(entry, "status");
+      const propstats = davChildren(entry, "propstat");
+      if (wholeStatus) {
+        if (propstats.length) throw new Error("conflicting response status and propstat");
+        this.httpError(statusCode(wholeStatus), "PROPFIND", path);
+      }
+      if (propstats.length === 0) throw new Error("missing resource identity propstat");
+      let seen = false;
+      let identifier;
+      for (const propstat of propstats) {
+        const status = davChild(propstat, "status");
+        const prop = davChild(propstat, "prop");
+        if (!status || !prop) throw new Error("incomplete resource identity propstat");
+        const code = statusCode(status);
+        if (code !== 200 && code !== 404) this.httpError(code, "PROPFIND", path);
+        for (const property of davChildren(prop, "resource-id")) {
+          if (seen) throw new Error("duplicate or conflicting resource identity property");
+          seen = true;
+          if (code === 404) continue;
+          const value = davChild(property, "href");
+          if (!value || property.children.length !== 1 || property.text.trim()) throw new Error("invalid resource identity property");
+          identifier = resourceIdentifier(scalar(value));
+        }
+      }
+      const owned = ownedResponseIdentifier(response, path);
+      if (owned !== void 0 && identifier !== void 0 && resourceIdentifier(owned) !== identifier) {
+        throw new Error("resource identity contradicts provider provenance");
+      }
+      return identifier;
+    });
+  }
+  url(path, collection = false) {
+    const relative = path.slice(1).split("/").map(encodeURIComponent).join("/");
+    return `${this.base.href}${relative}${collection && relative ? "/" : ""}`;
+  }
+  hrefPath(href) {
+    try {
+      validateUrlText(href);
+      if (!(href.startsWith("/") && !href.startsWith("//")) && !/^https?:\/\//i.test(href)) throw new Error("href must be absolute");
+      const url = new URL(href, this.base);
+      if (url.origin !== this.base.origin || url.username || url.password || url.search || url.hash) throw new Error("href is not confined");
+      const segments = urlSegments(url);
+      if (segments.length < this.baseSegments.length || this.baseSegments.some((segment, index) => segments[index] !== segment)) {
+        throw new Error("href escapes root");
+      }
+      return normalize(`/${segments.slice(this.baseSegments.length).join("/")}`);
+    } catch (cause) {
+      throw new FsError("EACCES", { syscall: "webdav", message: "response URL escapes or ambiguously addresses WebDAV root", cause });
+    }
+  }
+  httpError(status, method, path, exclusive = false) {
+    const codes = {
+      400: "EINVAL",
+      401: "EACCES",
+      403: "EACCES",
+      404: "ENOENT",
+      405: method === "MKCOL" ? "EEXIST" : "ENOTSUP",
+      408: "ETIMEDOUT",
+      409: method === "PUT" || method === "MKCOL" ? "ENOENT" : "EINVAL",
+      410: "ENOENT",
+      412: exclusive ? "EEXIST" : "EAGAIN",
+      413: "EFBIG",
+      414: "ENAMETOOLONG",
+      415: "ENOTSUP",
+      423: "EBUSY",
+      429: "EAGAIN",
+      501: "ENOTSUP",
+      503: "EAGAIN",
+      504: "ETIMEDOUT",
+      507: "ENOSPC"
+    };
+    fail3(
+      status >= 300 && status < 400 ? "ENOTSUP" : codes[status] ?? "EIO",
+      method,
+      path,
+      status >= 300 && status < 400 ? "WebDAV redirects are not followed" : `WebDAV HTTP status ${status}`
+    );
+  }
+  async request(method, path, options, init, consume, collection = false, received) {
+    for await (const result of this.requestStream(method, path, options, init, async function* (response, signal) {
+      yield await consume(response, signal);
+    }, collection, received)) return result;
+    throw new Error("missing WebDAV response");
+  }
+  async *requestStream(method, path, options, init, consume, collection = false, received) {
+    if (options.signal?.aborted) fail3("ECANCELED", method, path);
+    const walk = this.walkDeadlines.get(options);
+    const deadline = walk?.deadline ?? createRequestTimeout(this.timeoutMs);
+    if (walk) walk.deadline = deadline;
+    const timeout = deadline.signal;
+    try {
+      const headers = new Headers(this.headers);
+      for (const [name, value] of new Headers(init.headers)) headers.set(name, value);
+      headers.set("Cache-Control", "no-cache");
+      const signalScope = options.signal ? composeAbortSignals([timeout, options.signal]) : void 0;
+      const signal = signalScope?.signal ?? timeout;
+      let response;
+      const receive = (value, late) => {
+        if (value.redirected || value.type === "opaqueredirect") fail3("ENOTSUP", method, path, "transport followed or hid a redirect");
+        if (value.url && this.hrefPath(value.url) !== path) fail3("EACCES", method, path, "transport changed the requested resource");
+        received?.(value, late);
+      };
+      try {
+        let url = this.url(path, collection);
+        for (let attempt = 0; ; attempt++) {
+          signal.throwIfAborted();
+          response = await new Promise((resolve, reject) => {
+            let abandoned = false;
+            const abort = () => {
+              abandoned = true;
+              signal.removeEventListener("abort", abort);
+              reject(signal.reason);
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            try {
+              Promise.resolve(this.transport(url, {
+                ...init,
+                method,
+                headers,
+                redirect: "manual",
+                credentials: "omit",
+                signal
+              })).then((value) => {
+                signal.removeEventListener("abort", abort);
+                if (!abandoned) resolve(value);
+                else {
+                  try {
+                    receive(value, true);
+                  } catch (ignoredError) {
+                    void ignoredError;
+                  } finally {
+                    if (value.body && !value.body.locked) void value.body.cancel(signal.reason).catch(() => {
+                    });
+                  }
+                }
+              }, (error) => {
+                signal.removeEventListener("abort", abort);
+                reject(error);
+              }).catch(reject);
+            } catch (error) {
+              signal.removeEventListener("abort", abort);
+              reject(error);
+            }
+          });
+          receive(response, false);
+          signal.throwIfAborted();
+          const location = response.headers.get("Location");
+          if (attempt === 0 && method === "PROPFIND" && !url.endsWith("/") && [301, 302, 307, 308].includes(response.status) && location !== null && this.hrefPath(location) === path && new URL(location, this.base).href === `${url}/`) {
+            await response.body?.cancel();
+            signal.throwIfAborted();
+            url += "/";
+            continue;
+          }
+          yield* consume(response, signal);
+          return;
+        }
+      } catch (cause) {
+        if (options.signal?.aborted) throw new FsError("ECANCELED", { syscall: method, path, cause });
+        if (timeout.aborted) throw new FsError("ETIMEDOUT", { syscall: method, path, cause });
+        if (isFsError(cause)) throw cause;
+        throw new FsError("EIO", { syscall: method, path, message: "WebDAV transport or response failure", cause });
+      } finally {
+        signalScope?.dispose();
+        if (response?.body && !response.body.locked) void response.body.cancel().catch(() => {
+        });
+      }
+    } finally {
+      if (!walk) deadline.dispose();
+    }
+  }
+  async bytes(response, limit, signal) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of this.bodyChunks(response, limit, signal)) {
+      chunks.push(chunk);
+      size += chunk.byteLength;
+    }
+    const data = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return data;
+  }
+  async *bodyChunks(response, limit, signal) {
+    const length = response.headers.get("content-length");
+    if (length !== null && (!/^\d+$/.test(length) || !Number.isSafeInteger(Number(length)))) {
+      fail3("EIO", "webdav", "", "invalid response Content-Length");
+    }
+    const encoding = response.headers.get("content-encoding");
+    const expected = length !== null && (!encoding || encoding.toLowerCase() === "identity") ? Number(length) : void 0;
+    if (expected !== void 0 && expected > limit) fail3("EFBIG", "webdav", "", "response exceeds byte limit");
+    if (!response.body) {
+      if (expected !== void 0 && expected !== 0) fail3("EIO", "webdav", "", "response body length differs from Content-Length");
+      return;
+    }
+    const reader = response.body.getReader();
+    let size = 0;
+    const abort = () => {
+      void reader.cancel(signal.reason).catch(() => {
+      });
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      while (true) {
+        signal.throwIfAborted();
+        const result = await reader.read();
+        signal.throwIfAborted();
+        if (result.done) break;
+        size += result.value.byteLength;
+        if (size > limit) fail3("EFBIG", "webdav", "", "response exceeds byte limit");
+        if (expected !== void 0 && size > expected) fail3("EIO", "webdav", "", "response body length differs from Content-Length");
+        yield new Uint8Array(result.value);
+      }
+      if (expected !== void 0 && size !== expected) fail3("EIO", "webdav", "", "response body length differs from Content-Length");
+    } finally {
+      signal.removeEventListener("abort", abort);
+      void reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+  async xml(response, signal, maxResponses) {
+    const data = await this.bytes(response, this.maxXmlBytes, signal);
+    const encoding = data[0] === 255 && data[1] === 254 || data[0] === 60 && data[1] === 0 ? "utf-16le" : data[0] === 254 && data[1] === 255 || data[0] === 0 && data[1] === 60 ? "utf-16be" : "utf-8";
+    return parseXml2(new TextDecoder(encoding, { fatal: true }).decode(data), maxResponses === void 0 ? void 0 : { maxResponses });
+  }
+  async multistatus(response, signal, method = "PROPFIND", path = "") {
+    const link = response.headers.get("link");
+    if (link && /\brel\s*=\s*(?:"[^"]*\bnext\b[^"]*"|'[^']*\bnext\b[^']*'|next\b)/i.test(link)) {
+      fail3("ENOTSUP", method, path, "paginated WebDAV responses are unsupported");
+    }
+    let root;
+    try {
+      root = await this.xml(response, signal, this.maxEntries);
+    } catch (error) {
+      if (error instanceof XmlResponseLimitError) fail3("EFBIG", method, path, "response exceeds entry limit");
+      throw error;
+    }
+    if (root.namespace !== "DAV:" || root.localName !== "multistatus") throw new Error("expected DAV:multistatus");
+    const responses2 = davChildren(root, "response");
+    if (responses2.length > this.maxEntries) fail3("EFBIG", method, path, "response exceeds entry limit");
+    return responses2;
+  }
+  async lockFailure(response, signal, path) {
+    try {
+      const members = /* @__PURE__ */ new Set();
+      let failure;
+      for (const element of await this.multistatus(response, signal, "LOCK", path)) {
+        const href = davChild(element, "href");
+        const status = davChild(element, "status");
+        if (!href || !status) throw new Error("invalid LOCK multistatus");
+        const member = this.hrefPath(scalar(href));
+        if (member !== path && !member.startsWith(`${path}/`)) {
+          fail3("EACCES", "LOCK", path, "LOCK response member is outside requested subtree");
+        }
+        if (members.has(member)) throw new Error("duplicate LOCK response href");
+        members.add(member);
+        const code = statusCode(status);
+        if (code >= 300 && (!failure || failure.status === 424 && code !== 424)) {
+          failure = { member, status: code };
+        }
+      }
+      if (!failure) throw new Error("LOCK multistatus without a reported failure");
+      this.httpError(failure.status, "LOCK", failure.member);
+    } catch (cause) {
+      throw new FsError(isFsError(cause) ? cause.code : "EIO", {
+        syscall: "LOCK",
+        path,
+        message: "WebDAV LOCK multistatus failure",
+        cause
+      });
+    }
+  }
+  entryStat(element, path) {
+    const wholeStatus = davChild(element, "status");
+    if (wholeStatus) {
+      const code = statusCode(wholeStatus);
+      if (code < 200 || code >= 300) this.httpError(code, "PROPFIND", path);
+    }
+    const properties = /* @__PURE__ */ new Map();
+    const failures = /* @__PURE__ */ new Map();
+    let timestampProperty;
+    let timestampSeen = false;
+    for (const propstat of davChildren(element, "propstat")) {
+      const status = davChild(propstat, "status");
+      const prop = davChild(propstat, "prop");
+      if (!status || !prop) throw new Error("incomplete DAV:propstat");
+      const code = statusCode(status);
+      for (const property of prop.children) {
+        if (property.namespace === timestampNamespace && property.localName === "timestamps") {
+          if (timestampSeen) throw new Error("duplicate timestamp property");
+          timestampSeen = true;
+          if (code === 200) timestampProperty = property;
+        }
+        if (property.namespace !== "DAV:") continue;
+        if (properties.has(property.localName) || failures.has(property.localName)) throw new Error("duplicate DAV property");
+        if (code >= 200 && code < 300) properties.set(property.localName, property);
+        else failures.set(property.localName, code);
+      }
+    }
+    const required = (name) => {
+      const property = properties.get(name);
+      if (property) return property;
+      const failure = failures.get(name);
+      if (failure !== void 0 && failure !== 404) this.httpError(failure, "PROPFIND", path);
+      return fail3("ENOTSUP", "stat", path, `server does not expose DAV:${name}`);
+    };
+    const resourceType = required("resourcetype");
+    const directory = !!davChild(resourceType, "collection");
+    if (resourceType.text.trim() || resourceType.children.some((child) => child.namespace !== "DAV:" || child.localName !== "collection")) {
+      fail3("ENOTSUP", "stat", path, "unsupported DAV resource type");
+    }
+    const sizeText = directory ? "0" : scalar(required("getcontentlength"));
+    if (!/^\d+$/.test(sizeText) || !Number.isSafeInteger(Number(sizeText))) throw new Error("invalid content length property");
+    const date = (name) => {
+      const property = properties.get(name);
+      if (!property) return void 0;
+      const value = Date.parse(scalar(property));
+      if (!Number.isFinite(value)) throw new Error("invalid date property");
+      return value;
+    };
+    const birthtimeMs = date("creationdate");
+    const etag = properties.get("getetag");
+    const validator = etag && scalar(etag);
+    let mtimeMs = date("getlastmodified") ?? 0;
+    let atimeMs = 0;
+    if (timestampProperty) {
+      const timestamps = JSON.parse(scalar(timestampProperty));
+      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")) {
+        mtimeMs = timestamps.mtimeMs;
+        atimeMs = timestamps.atimeMs;
+      }
+    }
+    const stat = {
+      type: directory ? "directory" : "file",
+      size: Number(sizeText),
+      mode: directory ? 16895 : 33206,
+      mtimeMs,
+      atimeMs,
+      ctimeMs: 0,
+      ...birthtimeMs === void 0 ? {} : { birthtimeMs }
+    };
+    if (validator) this.etags.set(stat, validator);
+    return stat;
+  }
+  async entries(path, depth, options, collection = depth === "1", limit) {
+    return this.request("PROPFIND", path, options, {
+      headers: { Depth: depth, "Content-Type": "application/xml; charset=utf-8" },
+      body: propfindBody
+    }, async (response, signal) => {
+      if (response.status !== 207) this.httpError(response.status, "PROPFIND", path);
+      const result = /* @__PURE__ */ new Map();
+      let children = 0;
+      for (const element of await this.multistatus(response, signal)) {
+        signal.throwIfAborted();
+        const href = davChild(element, "href");
+        if (!href) throw new Error("missing DAV:href");
+        const member = this.hrefPath(scalar(href));
+        const prefix = path === "/" ? "/" : `${path}/`;
+        if (member !== path && (depth === "0" || !member.startsWith(prefix) || member.slice(prefix.length).includes("/"))) {
+          fail3("EACCES", "PROPFIND", path, "response member is outside requested depth");
+        }
+        if (result.has(member)) throw new Error("duplicate response href");
+        if (member !== path) admitDirectoryEntries(++children, limit, path);
+        const stat = this.entryStat(element, member);
+        recordOwnedResourceStat(response, this, member, stat);
+        result.set(member, stat);
+      }
+      if (!result.has(path)) throw new Error("response omitted requested resource");
+      return result;
+    }, collection);
+  }
+  async mutation(method, path, options, init = {}, collection = false) {
+    await this.request(method, path, options, init, async (response, signal) => {
+      if (response.status === 207) {
+        for (const element of await this.multistatus(response, signal)) {
+          const href = davChild(element, "href");
+          const status = davChild(element, "status");
+          if (!href || !status) throw new Error("invalid mutation multistatus");
+          const member = this.hrefPath(scalar(href));
+          const code = statusCode(status);
+          if (code < 200 || code >= 300) {
+            try {
+              this.httpError(code, method, member);
+            } catch (cause) {
+              throw new FsError("EIO", { syscall: method, path, message: "WebDAV mutation partially failed", cause });
+            }
+          }
+        }
+        fail3("EIO", method, path, "unexpected mutation multistatus without a reported failure");
+      }
+      const accepted = method === "PUT" ? [200, 201, 204] : method === "MKCOL" ? [201] : method === "DELETE" ? [204] : [201, 204];
+      if (!accepted.includes(response.status)) {
+        const headers = new Headers(init.headers);
+        this.httpError(response.status, method, path, headers.get("If-None-Match") === "*" || headers.get("Overwrite") === "F");
+      }
+    }, collection);
+  }
+  unsupported(operation, path) {
+    return fail3("ENOTSUP", operation, path, `${operation} has no safe portable WebDAV equivalent`);
+  }
+  async maybeStat(path, options) {
+    try {
+      return await this.stat(path, options);
+    } catch (error) {
+      if (isFsError(error, "ENOENT")) return void 0;
+      throw error;
+    }
+  }
+  async withWalkDeadline(options, walk) {
+    if (this.walkDeadlines.has(options)) return walk(options);
+    const scopedOptions = { ...options };
+    const owned = {};
+    this.walkDeadlines.set(scopedOptions, owned);
+    try {
+      return await walk(scopedOptions);
+    } finally {
+      owned.deadline?.dispose();
+      this.walkDeadlines.delete(scopedOptions);
+    }
+  }
+  async stat(path, options = {}) {
+    validateDirectoryWalkPath(path, "stat");
+    return this.statWithAncestors(path, options);
+  }
+  async statWithAncestors(path, options) {
+    const normalized = normalize(path);
+    const collection = requiresCollection(path);
+    return this.withWalkDeadline(options, async (scopedOptions) => {
+      try {
+        const stat = (await this.entries(normalized, "0", scopedOptions, collection)).get(normalized);
+        if (collection && stat.type !== "directory") fail3("ENOTDIR", "stat", path);
+        return stat;
+      } catch (error) {
+        if (!isFsError(error, "ENOENT")) throw error;
+        let parent = "";
+        for (const segment of normalized.slice(1).split("/").slice(0, -1)) {
+          parent += `/${segment}`;
+          const ancestor = (await this.entries(parent, "0", scopedOptions)).get(parent);
+          if (ancestor.type !== "directory") fail3("ENOTDIR", "stat", path);
+        }
+        throw error;
+      }
+    });
+  }
+  async lstat(path, options = {}) {
+    return this.stat(path, options);
+  }
+  async readdir(path, options = {}) {
+    let limit;
+    if (options.maxEntries !== void 0) {
+      if (options.signal?.aborted) fail3("ECANCELED", "readdir", path);
+      limit = directoryEntryLimit(options, path);
+    }
+    const normalized = normalize(path);
+    const entries2 = await this.entries(normalized, "1", options, true, limit);
+    if (entries2.get(normalized).type !== "directory") fail3("ENOTDIR", "readdir", path);
+    return [...entries2].filter(([member]) => member !== normalized).map(([member, stat]) => ({ name: member.slice(member.lastIndexOf("/") + 1), type: stat.type })).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  }
+  async readFile(path, options = {}) {
+    const normalized = normalize(path);
+    const limit = Math.min(this.maxResponseBytes, positive(options.maxBytes ?? this.maxResponseBytes, "maxBytes", true));
+    if ((await this.stat(path, options)).type === "directory") fail3("EISDIR", "readFile", path);
+    return this.request("GET", normalized, options, { headers: { "Accept-Encoding": "identity" } }, async (response, signal) => {
+      if (response.status !== 200) this.httpError(response.status, "GET", path);
+      return this.bytes(response, limit, signal);
+    });
+  }
+  async *readStream(path, options = {}) {
+    const normalized = normalize(path);
+    const start = positive(options.start ?? 0, "start", true);
+    const end = options.endExclusive === void 0 ? Infinity : positive(options.endExclusive, "endExclusive", true);
+    const chunkSize2 = positive(options.chunkSize ?? 64 * 1024, "chunkSize");
+    if (end < start) fail3("EINVAL", "readStream", path, "endExclusive precedes start");
+    if ((await this.stat(path, options)).type === "directory") fail3("EISDIR", "readStream", path);
+    yield* this.requestStream("GET", normalized, options, { headers: { "Accept-Encoding": "identity" } }, async function* (response, signal) {
+      if (response.status !== 200) this.httpError(response.status, "GET", path);
+      let position = 0;
+      for await (const chunk of this.bodyChunks(response, this.maxResponseBytes, signal)) {
+        const first = Math.max(0, start - position);
+        const last = Math.min(chunk.byteLength, end - position);
+        for (let offset = first; offset < last; offset += chunkSize2) {
+          signal.throwIfAborted();
+          yield chunk.slice(offset, Math.min(last, offset + chunkSize2));
+        }
+        position += chunk.byteLength;
+        if (position >= end) return;
+      }
+    }.bind(this));
+  }
+  async prepareWrite(path, options) {
+    validateDirectoryWalkPath(path, "writeFile");
+    const normalized = normalize(path);
+    if (options.mode !== void 0) this.unsupported("writeFile mode", path);
+    if (options.flag !== void 0 && !["w", "wx", "a", "ax"].includes(options.flag)) fail3("EINVAL", "writeFile", path);
+    if (options.signal?.aborted) fail3("ECANCELED", "writeFile", path);
+    if (normalized === "/") fail3("EISDIR", "writeFile", path);
+    return this.withWalkDeadline(options, async (scopedOptions) => {
+      if (requiresCollection(path)) {
+        await this.stat(path, scopedOptions);
+        fail3("EISDIR", "writeFile", path);
+      }
+      let parent = "";
+      for (const segment of normalized.slice(1).split("/").slice(0, -1)) {
+        parent += `/${segment}`;
+        await this.stat(`${parent}/`, scopedOptions);
+      }
+      const exclusive = options.flag === "wx" || options.flag === "ax";
+      const existing = exclusive ? void 0 : await this.maybeStat(normalized, scopedOptions);
+      if (existing?.type === "directory") fail3("EISDIR", "writeFile", path);
+      let prefix = new Uint8Array();
+      const headers = { "Content-Type": "application/octet-stream" };
+      if (exclusive || options.flag === "a" && !existing) headers["If-None-Match"] = "*";
+      if (options.flag === "a" && existing) {
+        const snapshot = await this.request("GET", normalized, scopedOptions, { headers: { "Accept-Encoding": "identity" } }, async (response, signal) => {
+          if (response.status !== 200) this.httpError(response.status, "GET", path);
+          const etag = strongEtag(response.headers.get("ETag"), path);
+          if (response.headers.get("Content-Encoding") && response.headers.get("Content-Encoding").toLowerCase() !== "identity") {
+            fail3("ENOTSUP", "appendFile", path, "conditional append requires an identity representation");
+          }
+          return { etag, data: await this.bytes(response, this.maxResponseBytes, signal) };
+        });
+        prefix = snapshot.data;
+        headers["If-Match"] = snapshot.etag;
+      }
+      return { normalized, headers, prefix };
+    });
+  }
+  async writeFile(path, data, options = {}) {
+    if (!(data instanceof Uint8Array)) fail3("EINVAL", "writeFile", path, "data must be Uint8Array");
+    const { normalized, headers, prefix } = await this.prepareWrite(path, options);
+    if (options.flag === "a" && prefix.byteLength + data.byteLength > this.maxResponseBytes) fail3("EFBIG", "appendFile", path);
+    const body = new Uint8Array(prefix.byteLength + data.byteLength);
+    body.set(prefix);
+    body.set(data, prefix.byteLength);
+    await this.mutation("PUT", normalized, options, {
+      headers,
+      body
+    });
+  }
+  async writeStream(path, source, options = {}) {
+    if (options.signal?.aborted) fail3("ECANCELED", "writeStream", path);
+    if (this.requestStreamSupport === false || this.requestStreamSupport === "native" && !nativeRequestStreamsSupported(this.base.href)) {
+      fail3("ENOTSUP", "writeStream", path, "transport does not declare supported request streams");
+    }
+    const { normalized, headers, prefix } = await this.prepareWrite(path, options);
+    const deadline = createRequestTimeout(this.timeoutMs);
+    const timeout = deadline.signal;
+    try {
+      const controller = new AbortController();
+      const signalScope = composeAbortSignals([timeout, controller.signal, ...options.signal ? [options.signal] : []]);
+      const signal = signalScope.signal;
+      const limit = this.maxResponseBytes;
+      const chunks = (async function* () {
+        let size = prefix.byteLength;
+        if (prefix.byteLength) yield prefix;
+        for await (const chunk of readBytes2(source, signal)) {
+          size += chunk.byteLength;
+          if (size > limit) fail3("EFBIG", "writeStream", path, "upload exceeds byte limit");
+          yield new Uint8Array(chunk);
+        }
+      })();
+      let finished = false;
+      let uploadError;
+      let body;
+      try {
+        body = new ReadableStream({
+          async pull(destination) {
+            try {
+              const result = await chunks.next();
+              if (result.done) {
+                finished = true;
+                destination.close();
+              } else destination.enqueue(result.value);
+            } catch (cause) {
+              uploadError = cause;
+              destination.error(cause);
+            }
+          },
+          cancel(reason) {
+            controller.abort(reason);
+            void chunks.return(void 0).catch(() => {
+            });
+          }
+        }, { highWaterMark: 0 });
+        try {
+          const request = { headers, body, duplex: "half" };
+          await this.mutation("PUT", normalized, options, request);
+          if (uploadError !== void 0) throw uploadError;
+          if (!finished) fail3("EIO", "writeStream", path, "server responded before consuming the upload");
+        } catch (cause) {
+          if (options.signal?.aborted) throw new FsError("ECANCELED", { syscall: "writeStream", path, cause });
+          if (timeout.aborted) throw new FsError("ETIMEDOUT", { syscall: "writeStream", path, cause });
+          if (isFsError(uploadError)) throw uploadError;
+          if (isFsError(cause)) throw cause;
+          throw new FsError("EIO", { syscall: "writeStream", path, cause });
+        }
+      } finally {
+        controller.abort();
+        signalScope.dispose();
+        if (body && !body.locked) void body.cancel().catch(() => {
+        });
+        void chunks.return(void 0).catch(() => {
+        });
+      }
+    } finally {
+      deadline.dispose();
+    }
+  }
+  async appendFile(path, data, options = {}) {
+    await this.writeFile(path, data, { ...options, flag: "a" });
+  }
+  async mkdir(path, options = {}) {
+    const normalized = normalize(path);
+    if (options.mode !== void 0) this.unsupported("mkdir mode", path);
+    if (!options.recursive) {
+      if (normalized === "/") fail3("EEXIST", "mkdir", path);
+      return this.mutation("MKCOL", normalized, options, {}, true);
+    }
+    let current = "";
+    for (const segment of normalized.slice(1).split("/").filter(Boolean)) {
+      current += `/${segment}`;
+      const existing = await this.maybeStat(`${current}/`, options);
+      if (existing) {
+        if (existing.type !== "directory") fail3("ENOTDIR", "mkdir", current);
+        continue;
+      }
+      try {
+        await this.mutation("MKCOL", current, options, {}, true);
+      } catch (error) {
+        if (!isFsError(error, "EEXIST")) throw error;
+        if ((await this.stat(`${current}/`, options)).type !== "directory") fail3("ENOTDIR", "mkdir", current);
+      }
+    }
+    if (normalized === "/") await this.stat(normalized, options);
+  }
+  async rmdir(path, options = {}) {
+    try {
+      const normalized = normalize(path);
+      if (options.signal?.aborted) fail3("ECANCELED", "rmdir", path);
+      if (normalized === "/") fail3("EBUSY", "rmdir", path, "cannot remove WebDAV root");
+      const stat = await this.stat(path, options);
+      if (options.signal?.aborted) fail3("ECANCELED", "rmdir", path);
+      if (stat.type !== "directory") fail3("ENOTDIR", "rmdir", path);
+      if (this.atomicEmptyDirectory) {
+        await this.atomicRmdir(normalized, path, options);
+        return;
+      }
+      const entries2 = await this.readdir(path, options);
+      if (options.signal?.aborted) fail3("ECANCELED", "rmdir", path);
+      if (entries2.length) fail3("ENOTEMPTY", "rmdir", path);
+      this.unsupported("rmdir", path);
+    } catch (error) {
+      if (isFsError(error) && (error.syscall !== "rmdir" || error.path !== path)) {
+        throw new FsError(error.code, { syscall: "rmdir", path, cause: error });
+      }
+      throw error;
+    }
+  }
+  async atomicRmdir(normalized, path, options) {
+    const deadline = createRequestTimeout(this.timeoutMs);
+    const timeout = deadline.signal;
+    try {
+      const signalScope = options.signal ? composeAbortSignals([timeout, options.signal]) : void 0;
+      const signal = signalScope?.signal ?? timeout;
+      try {
+        signal.throwIfAborted();
+        const receipt = await new Promise((resolve, reject) => {
+          const abort = () => {
+            signal.removeEventListener("abort", abort);
+            reject(signal.reason);
+          };
+          signal.addEventListener("abort", abort, { once: true });
+          try {
+            Promise.resolve(this.atomicEmptyDirectory.removeEmptyDirectory(Object.freeze({
+              operation: "atomic-empty-rmdir/v1",
+              namespaceUrl: this.base.href,
+              path: normalized,
+              signal
+            }))).then((result) => {
+              signal.removeEventListener("abort", abort);
+              resolve(result);
+            }, (error) => {
+              signal.removeEventListener("abort", abort);
+              reject(error);
+            });
+          } catch (error) {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+          }
+        });
+        signal.throwIfAborted();
+        if (!receipt || receipt.operation !== "atomic-empty-rmdir/v1" || receipt.namespaceUrl !== this.base.href || receipt.path !== normalized || receipt.outcome !== "removed") {
+          fail3("EIO", "rmdir", path, "atomic empty-directory receipt mismatch; removal outcome is uncertain");
+        }
+      } catch (cause) {
+        if (options.signal?.aborted) throw new FsError("ECANCELED", { syscall: "rmdir", path, cause });
+        if (timeout.aborted) throw new FsError("ETIMEDOUT", { syscall: "rmdir", path, cause });
+        if (isFsError(cause)) throw cause;
+        const code = cause && typeof cause === "object" && "code" in cause && isErrnoCode(cause.code) ? cause.code : "EIO";
+        throw new FsError(code, { syscall: "rmdir", path, cause });
+      } finally {
+        signalScope?.dispose();
+      }
+    } finally {
+      deadline.dispose();
+    }
+  }
+  async rm(path, options = {}) {
+    const normalized = normalize(path);
+    if (normalized === "/") fail3("EBUSY", "rm", path, "cannot remove WebDAV root");
+    try {
+      const stat = await this.stat(path, options);
+      if (stat.type === "directory" && !options.recursive) this.unsupported("nonrecursive directory removal", path);
+      await this.mutation("DELETE", normalized, options, {}, stat.type === "directory");
+    } catch (error) {
+      if (!(options.force && isFsError(error, "ENOENT"))) throw error;
+    }
+  }
+  async guardTransferIdentity(source, destination, options) {
+    if (!this.configuredComparison && this.compareEntry === originalWebDavComparison) return;
+    const comparison = await compareEntries(this, source, this, destination, options);
+    if (source === destination) {
+      if (comparison === "distinct") fail3("EIO", "compareEntry", source, "comparison contradicts identical WebDAV paths");
+      return;
+    }
+    if (comparison === "same") fail3("EINVAL", "compareEntry", destination, "source and destination refer to the same entry");
+    if (comparison === "unknown") fail3("ENOTSUP", "compareEntry", destination, "configured authority cannot establish distinct entries");
+  }
+  async transfer(method, source, destination, options) {
+    const from = normalize(source);
+    const to = normalize(destination);
+    if (from === "/" || to === "/") fail3("EBUSY", method, source, "cannot replace or transfer WebDAV root");
+    const stat = await this.stat(source, options);
+    if (method === "COPY" && stat.type === "directory") fail3("EISDIR", "copyFile", source);
+    if (requiresCollection(destination) && stat.type !== "directory") fail3("ENOTDIR", method, destination);
+    if (from === to) {
+      await this.guardTransferIdentity(from, to, options);
+      if (method === "MOVE") return;
+      fail3(options.exclusive ? "EEXIST" : "EINVAL", "copyFile", source, "source and destination are identical");
+    }
+    if (stat.type === "directory" && to.startsWith(`${from}/`)) fail3("EINVAL", method, destination, "cannot move directory into itself");
+    const existing = await this.maybeStat(destination, options);
+    if (existing) await this.guardTransferIdentity(from, to, options);
+    if (existing && options.exclusive) fail3("EEXIST", method, destination);
+    const checkType = (target) => {
+      if (target.type === "directory" && stat.type === "file") fail3("EISDIR", method, destination);
+      if (target.type !== "directory" && stat.type === "directory") fail3("ENOTDIR", method, destination);
+    };
+    if (existing) checkType(existing);
+    if (stat.type === "directory" && from.startsWith(`${to}/`)) fail3("EINVAL", method, destination, "cannot replace an ancestor of the source");
+    const destinationUrl = this.url(to, stat.type === "directory");
+    const headers = {
+      Destination: destinationUrl,
+      Overwrite: existing ? "T" : "F",
+      Depth: method === "COPY" ? "0" : "infinity"
+    };
+    const sourceEtag = this.etags.get(stat);
+    if (existing && sourceEtag && /^"[\x21\x23-\x7e\x80-\xff]*"$/.test(sourceEtag)) headers["If-Match"] = sourceEtag;
+    const mutate = () => this.mutation(method, from, options, { headers }, stat.type === "directory");
+    if (!existing) return mutate();
+    if (this.overwritePolicy === "etag" && existing.type === "file") {
+      headers.If = `<${destinationUrl}> ([${strongEtag(this.etags.get(existing), destination)}])`;
+      return mutate();
+    }
+    await this.withDestinationLock(to, existing, options, async (token) => {
+      const locked = await this.stat(destination, options);
+      checkType(locked);
+      if (locked.type === "directory" && (await this.readdir(destination, options)).length) fail3("ENOTEMPTY", method, destination);
+      headers.If = `<${destinationUrl}> (${token})`;
+      await mutate();
+    });
+  }
+  async withDestinationLock(path, stat, options, operation) {
+    let token;
+    const collection = stat.type === "directory";
+    const validator = this.etags.get(stat);
+    const unlock = async (value) => {
+      await this.request("UNLOCK", path, {}, { headers: { "Lock-Token": value } }, async (response) => {
+        if (response.status !== 204) this.httpError(response.status, "UNLOCK", path);
+      }, collection).catch(() => {
+      });
+    };
+    try {
+      await this.request("LOCK", path, options, {
+        headers: {
+          "Content-Type": "application/xml; charset=utf-8",
+          Depth: "infinity",
+          Timeout: "Second-60",
+          "If-Match": validator && /^"[\x21\x23-\x7e\x80-\xff]*"$/.test(validator) ? validator : "*"
+        },
+        body: lockBody
+      }, async (response, signal) => {
+        if (response.status === 207) return this.lockFailure(response, signal, path);
+        if (response.status !== 200) this.httpError(response.status, "LOCK", path);
+        const root = await this.xml(response, signal);
+        const discovery = davChild(root, "lockdiscovery");
+        const active = discovery && davChild(discovery, "activelock");
+        const scope = active && davChild(active, "lockscope");
+        const type = active && davChild(active, "locktype");
+        const depth = active && davChild(active, "depth");
+        const lockToken = active && davChild(active, "locktoken");
+        const href = lockToken && davChild(lockToken, "href");
+        const lockRoot = active && davChild(active, "lockroot");
+        const rootHref = lockRoot && davChild(lockRoot, "href");
+        const timeout = active && davChild(active, "timeout");
+        if (root.namespace !== "DAV:" || root.localName !== "prop" || !scope || !davChild(scope, "exclusive") || davChild(scope, "shared") || !type || !davChild(type, "write") || !depth || scalar(depth) !== "infinity" || !href || `<${scalar(href)}>` !== token || lockRoot !== void 0 && (!rootHref || this.hrefPath(scalar(rootHref)) !== path) || !timeout || !/^Second-[1-9]\d*$/i.test(scalar(timeout)) || Number(scalar(timeout).slice(7)) > 4294967295) {
+          fail3("ENOTSUP", "LOCK", path, "server did not grant a finite exclusive depth-infinity write lock");
+        }
+      }, collection, (response, late) => {
+        if (response.status !== 200) return;
+        const header = response.headers.get("Lock-Token");
+        if (!header || !/^<[a-z][a-z0-9+.-]*:[^<>\s\x00-\x20\x7f]+>$/i.test(header)) throw new Error("invalid LOCK token");
+        if (late) void unlock(header);
+        else token = header;
+      });
+      await operation(token);
+    } finally {
+      if (token) await unlock(token);
+    }
+  }
+  async rename(source, destination, options = {}) {
+    if (options.noReplace) {
+      options.signal?.throwIfAborted();
+      fail3("ENOTSUP", "rename", source, "atomic no-replace rename is unsupported");
+    }
+    await this.transfer("MOVE", source, destination, options);
+  }
+  async copyFile(source, destination, options = {}) {
+    await this.transfer("COPY", source, destination, options);
+  }
+  async realpath(path, options = {}) {
+    const normalized = normalize(path);
+    await this.stat(path, options);
+    return normalized;
+  }
+  async access(path, mode2 = 0, options = {}) {
+    if (!Number.isInteger(mode2) || mode2 < 0 || mode2 > 7) fail3("EINVAL", "access", path);
+    if (options.signal?.aborted) fail3("ECANCELED", "access", path);
+    if (mode2 & 2) this.unsupported("access write/execute permission checks", path);
+    if (mode2 & 1) validateDirectoryWalkPath(path);
+    const stat = await (mode2 & 1 ? this.stat(path, options) : this.statWithAncestors(path, options));
+    if (options.signal?.aborted) fail3("ECANCELED", "access", path);
+    if (mode2 & 1 && stat.type !== "directory") this.unsupported("access execute permission checks", path);
+    if (mode2 & 4) {
+      if (stat.type === "directory") await this.readdir(path, options);
+      else await this.request("GET", normalize(path), options, { headers: { "Accept-Encoding": "identity" } }, async (response) => {
+        if (response.status !== 200) this.httpError(response.status, "GET", path);
+      });
+    }
+    if (options.signal?.aborted) fail3("ECANCELED", "access", path);
+  }
+  async readlink(path, _options = {}) {
+    return this.unsupported("readlink", path);
+  }
+  async symlink(_target, path, _options = {}) {
+    this.unsupported("symlink", path);
+  }
+  async link(_source, path, _options = {}) {
+    this.unsupported("link", path);
+  }
+  async chmod(path, _mode, _options = {}) {
+    this.unsupported("chmod", path);
+  }
+  async utimes(path, atimeMs, mtimeMs, options = {}) {
+    const normalized = normalize(path);
+    if (![atimeMs, mtimeMs].every((value) => Number.isFinite(value) && Math.abs(value) <= 864e13)) fail3("EINVAL", "utimes", path);
+    const stat = await this.stat(path, options);
+    const etag = strongEtag(this.etags.get(stat), path);
+    const metadata = JSON.stringify({ version: 1, etag, type: stat.type, atimeMs, mtimeMs }).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+    await this.request("PROPPATCH", normalized, options, {
+      headers: { "Content-Type": "application/xml; charset=utf-8", "If-Match": etag },
+      body: `<d:propertyupdate xmlns:d="DAV:" xmlns:v="${timestampNamespace}"><d:set><d:prop><v:timestamps>${metadata}</v:timestamps></d:prop></d:set></d:propertyupdate>`
+    }, async (response, signal) => {
+      if (response.status !== 207) this.httpError(response.status, "PROPPATCH", path);
+      const entries2 = await this.multistatus(response, signal);
+      if (entries2.length !== 1) throw new Error("PROPPATCH must report the requested resource");
+      const entry = entries2[0];
+      const href = davChild(entry, "href");
+      if (!href || this.hrefPath(scalar(href)) !== normalized) fail3("EACCES", "PROPPATCH", path, "unexpected response resource");
+      const status = davChild(entry, "status");
+      if (status) this.httpError(statusCode(status), "PROPPATCH", path);
+      const propstats = davChildren(entry, "propstat");
+      if (propstats.length !== 1) throw new Error("PROPPATCH must report the requested property");
+      const prop = davChild(propstats[0], "prop");
+      const result = davChild(propstats[0], "status");
+      const property = prop?.children[0];
+      if (!result || prop?.children.length !== 1 || property?.namespace !== timestampNamespace || property.localName !== "timestamps") throw new Error("invalid PROPPATCH property result");
+      const code = statusCode(result);
+      if (code !== 200) this.httpError(code, "PROPPATCH", path);
+    }, stat.type === "directory");
+    const updated = await this.stat(path, options);
+    if (updated.atimeMs !== atimeMs || updated.mtimeMs !== mtimeMs) {
+      fail3("EAGAIN", "utimes", path, "server did not retain requested timestamps for the current representation");
+    }
+  }
+  async truncate(path, _length, _options = {}) {
+    this.unsupported("truncate", path);
+  }
+};
+var originalWebDavComparison = WebDavFileSystem.prototype.compareEntry;
+
+// packages/safe-bash/src/integrations/safejs/filesystem.ts
+function makeSafeJsFsModule(makeFsModule, fs, options = {}) {
+  return makeFsModule({ adapter: fs, ...options });
+}
+
+// packages/safe-bash/src/integrations/safejs/shell.ts
+init_platform();
+function guestOptions(value) {
+  if (value === void 0) return {};
+  const options = record(value, "shell options");
+  onlyKeys(options, ["cwd", "env", "stdin"]);
+  const env = options.env === void 0 ? void 0 : record(options.env, "env");
+  const entries2 = env === void 0 ? void 0 : Object.entries(env).map(([key, entry]) => {
+    if (key.includes("\0") || key.includes("=")) throw new TypeError("Invalid environment key");
+    const text = stringValue(entry, `env.${key}`);
+    if (text.includes("\0")) throw new TypeError("Invalid environment value");
+    return [key, text];
+  });
+  return {
+    ...options.cwd === void 0 ? {} : { cwd: stringValue(options.cwd, "cwd") },
+    ...options.stdin === void 0 ? {} : { stdin: stringValue(options.stdin, "stdin") },
+    ...entries2 === void 0 ? {} : { env: Object.fromEntries(entries2) }
+  };
+}
+function makeSafeJsShellModule(executor, options) {
+  if (options.fs === void 0) throw new TypeError("An explicit filesystem is required");
+  if (!(options.signal instanceof AbortSignal)) throw new TypeError("An explicit signal is required");
+  if (options.replayPolicy !== "read-side-effect") {
+    throw new TypeError("Shell operations require the read-side-effect replay policy");
+  }
+  if (typeof options.declareHostOperation !== "function") {
+    throw new TypeError("SafeJS declareHostOperation must be injected");
+  }
+  const execute = typeof executor === "function" ? executor : executor.exec.bind(executor);
+  if (typeof execute !== "function") throw new TypeError("A shell executor is required");
+  async function exec(source, input) {
+    const text = stringValue(source, "source");
+    const request = guestOptions(input);
+    return withSignal(options.signal, async () => {
+      const result = await execute(text, { ...request, fs: options.fs, signal: options.signal });
+      if (!Number.isInteger(result.exitCode) || result.exitCode < 0 || result.exitCode > 255) {
+        throw new TypeError("Shell exitCode must be an integer between 0 and 255");
+      }
+      return {
+        stdout: stringValue(result.stdout, "stdout"),
+        stderr: stringValue(result.stderr, "stderr"),
+        exitCode: result.exitCode
+      };
+    });
+  }
+  return { exec: options.declareHostOperation(exec, options.replayPolicy) };
+}
+
+// packages/safe-bash/src/commands/safejs/io.ts
+init_platform();
+
+// packages/safe-bash/src/commands/safejs/types.ts
+init_platform();
+var SafeJsCommandLimitError = class extends Error {
+  constructor(resource) {
+    super(`SafeJS command limit exceeded: ${resource}`);
+    this.resource = resource;
+    this.name = "SafeJsCommandLimitError";
+  }
+  resource;
+  code = "SAFEJS_LIMIT";
+};
+
+// packages/safe-bash/src/commands/safejs/render.ts
+init_platform();
+var Text = class {
+  constructor(limit, fail) {
+    this.limit = limit;
+    this.fail = fail;
+  }
+  limit;
+  fail;
+  parts = [];
+  size = 0;
+  active = /* @__PURE__ */ new Set();
+  append(value) {
+    if (import_buffer.Buffer.byteLength(value) > this.limit - this.size) {
+      const error = new SafeJsCommandLimitError("maxOutputBytes");
+      this.fail(error);
+      throw error;
+    }
+    this.size += import_buffer.Buffer.byteLength(value);
+    this.parts.push(value);
+  }
+  quoted(value) {
+    if (import_buffer.Buffer.byteLength(value) + 2 > this.limit - this.size) {
+      const error = new SafeJsCommandLimitError("maxOutputBytes");
+      this.fail(error);
+      throw error;
+    }
+    this.append(JSON.stringify(value));
+  }
+  json(value, depth = 0) {
+    if (depth > 64) throw new TypeError("output JSON exceeds depth 64");
+    if (value === null || value === void 0) {
+      this.append("null");
+      return;
+    }
+    if (typeof value === "string") {
+      this.quoted(value);
+      return;
+    }
+    if (typeof value === "boolean" || typeof value === "number") {
+      this.append(JSON.stringify(value));
+      return;
+    }
+    if (typeof value !== "object" || this.active.has(value)) throw new TypeError("output requires acyclic JSON data");
+    this.active.add(value);
+    try {
+      if (Array.isArray(value)) {
+        this.append("[");
+        for (let index = 0; index < value.length; index++) {
+          if (index) this.append(",");
+          const property = Object.getOwnPropertyDescriptor(value, String(index));
+          if (property && !("value" in property)) throw new TypeError("output arrays must contain data properties");
+          this.json(property?.value, depth + 1);
+        }
+        this.append("]");
+      } else {
+        const entries2 = record(value, "output value");
+        this.append("{");
+        let first = true;
+        for (const [key, item] of Object.entries(entries2)) {
+          if (item === void 0) continue;
+          if (!first) this.append(",");
+          first = false;
+          this.quoted(key);
+          this.append(":");
+          this.json(item, depth + 1);
+        }
+        this.append("}");
+      }
+    } finally {
+      this.active.delete(value);
+    }
+  }
+  finish() {
+    return this.parts.join("");
+  }
+};
+function renderOutput(values, limit, fail) {
+  const text = new Text(limit, fail);
+  for (let index = 0; index < values.length; index++) {
+    if (index) text.append(" ");
+    const value = values[index];
+    if (typeof value === "string") text.append(value);
+    else if (value === void 0) text.append("undefined");
+    else text.json(value);
+  }
+  text.append("\n");
+  return text.finish();
+}
+
+// packages/safe-bash/src/commands/safejs/io.ts
+var chunkSize = 64 * 1024;
+var GuestInput = class {
+  constructor(source, limit, signal, fail, resource = "maxInputBytes") {
+    this.limit = limit;
+    this.signal = signal;
+    this.fail = fail;
+    this.resource = resource;
+    this.iterator = readBytes(source, signal);
+  }
+  limit;
+  signal;
+  fail;
+  resource;
+  iterator;
+  pending = new Uint8Array();
+  consumed = 0;
+  pulls = 0;
+  queue = Promise.resolve();
+  async take(size) {
+    this.signal.throwIfAborted();
+    while (!this.pending.length) {
+      if (++this.pulls % 64 === 0) await yieldTurn(this.signal);
+      const next = await this.iterator.next();
+      if (next.done) return void 0;
+      this.pending = next.value;
+    }
+    const length = Math.min(size, this.pending.length);
+    if (length > this.limit - this.consumed) {
+      const error = new SafeJsCommandLimitError(this.resource);
+      this.fail(error);
+      throw error;
+    }
+    const bytes = this.pending.slice(0, length);
+    this.pending = this.pending.subarray(length);
+    this.consumed += length;
+    return bytes;
+  }
+  serialize(operation) {
+    const result = this.queue.then(operation);
+    this.queue = result.then(() => {
+    }, () => {
+    });
+    return result;
+  }
+  readBytes(size = chunkSize) {
+    if (typeof size !== "number" || !Number.isSafeInteger(size) || size < 1 || size > chunkSize) throw new TypeError("readBytes size must be an integer from 1 through 65536");
+    return this.serialize(async () => {
+      const bytes = await this.take(size);
+      return bytes === void 0 ? null : Array.from(bytes);
+    });
+  }
+  readText() {
+    return this.serialize(async () => {
+      const pieces = [];
+      for (; ; ) {
+        const chunk = await this.take(chunkSize);
+        if (!chunk) break;
+        pieces.push(chunk);
+      }
+      return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(import_buffer.Buffer.concat(pieces));
+    });
+  }
+  async close() {
+    await this.iterator.return(void 0);
+  }
+};
+var GuestOutput = class {
+  constructor(stdout, stderr, limit, signal, fail) {
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.limit = limit;
+    this.signal = signal;
+    this.fail = fail;
+  }
+  stdout;
+  stderr;
+  limit;
+  signal;
+  fail;
+  queue = Promise.resolve();
+  produced = 0;
+  stderrFailed = false;
+  enqueue(bytes, target) {
+    this.signal.throwIfAborted();
+    if (bytes.length > this.limit - this.produced) {
+      const error = new SafeJsCommandLimitError("maxOutputBytes");
+      this.fail(error);
+      throw error;
+    }
+    this.produced += bytes.length;
+    const queued = this.queue.then(async () => {
+      for (let offset = 0; offset < bytes.length; offset += chunkSize) await writeBytes(target, bytes.subarray(offset, offset + chunkSize), this.signal);
+    }).catch((error) => {
+      if (target === this.stderr) this.stderrFailed = true;
+      this.fail(error);
+      throw error;
+    });
+    this.queue = queued;
+    void queued.catch(() => {
+    });
+    return queued;
+  }
+  text(value, stderr = false) {
+    if (typeof value !== "string") throw new TypeError("stdio text output requires a string");
+    if (import_buffer.Buffer.byteLength(value) > this.limit - this.produced) {
+      const error = new SafeJsCommandLimitError("maxOutputBytes");
+      this.fail(error);
+      throw error;
+    }
+    return this.enqueue(import_buffer.Buffer.from(value), stderr ? this.stderr : this.stdout);
+  }
+  bytes(value, stderr = false) {
+    if (!Array.isArray(value) || value.length > chunkSize) throw new TypeError("stdio byte output requires an array of at most 65536 bytes");
+    for (const byte of value) if (!Number.isInteger(byte) || byte < 0 || byte > 255) throw new TypeError("stdio byte values must be integers from 0 through 255");
+    return this.enqueue(Uint8Array.from(value), stderr ? this.stderr : this.stdout);
+  }
+  console(args, stderr) {
+    void this.text(renderOutput(args, this.limit - this.produced, this.fail), stderr);
+  }
+  result(value) {
+    return this.text(renderOutput([value], this.limit - this.produced, this.fail));
+  }
+  async drain() {
+    await this.queue;
+  }
+};
+
+// packages/safe-bash/src/commands/safejs/options.ts
+init_platform();
+var defaultSafeJsLimits = Object.freeze({
+  maxSourceBytes: 1024 * 1024,
+  maxInputBytes: 8 * 1024 * 1024,
+  maxOutputBytes: 8 * 1024 * 1024,
+  timeoutMs: 5e3,
+  maxSteps: 1e5,
+  maxCallDepth: 128,
+  stringLength: 1024 * 1024,
+  arrayLength: 1e5,
+  dataSize: 16 * 1024 * 1024
+});
+function commandLimits(options = {}) {
+  const result = { ...defaultSafeJsLimits, ...options };
+  for (const [name, value] of Object.entries(result)) {
+    if (!Object.hasOwn(defaultSafeJsLimits, name)) throw new TypeError(`Unknown SafeJS limit: ${name}`);
+    if (!Number.isSafeInteger(value) || value < (name === "timeoutMs" ? 1 : 0)) throw new RangeError(`Invalid SafeJS limit: ${name}`);
+  }
+  if (result.timeoutMs > 2147483647) throw new RangeError("SafeJS timeoutMs exceeds timer range");
+  return Object.freeze(result);
+}
+
+// packages/safe-bash/src/commands/safejs/runtime.ts
+var GuestDiagnostic = class extends PublicDiagnostic {
+  constructor(info) {
+    super(info.message);
+    this.info = info;
+  }
+  info;
+};
+function errorInfo(error) {
+  if (typeof error === "string") return { name: "Error", code: "", message: error };
+  if (typeof error !== "object" || error === null) return { name: "Error", code: "", message: "SafeJS execution failed" };
+  const field = (name) => {
+    const descriptor = Object.getOwnPropertyDescriptor(error, name);
+    return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : "";
+  };
+  return { name: field("name"), code: field("code"), message: field("message") || "SafeJS execution failed" };
+}
+function statusField(error, name) {
+  if (typeof error !== "object" || error === null) return "";
+  const descriptor = Object.getOwnPropertyDescriptor(error, name);
+  return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : "";
+}
+function validateRuntime(runtime) {
+  if (runtime === void 0) return;
+  for (const key of ["run", "createBudget", "makeFsModule", "declareHostOperation"]) {
+    if (typeof runtime[key] !== "function") throw new TypeError(`SafeJS runtime.${key} must be injected`);
+  }
+}
+function createSafeJsCommands(options, dialect) {
+  const limits = commandLimits(options.limits);
+  const runtime = options.runtime;
+  validateRuntime(runtime);
+  return [{ name: dialect.name, description: dialect.description, async execute(context) {
+    const deadline = Date.now() + limits.timeoutMs;
+    const diagnose = async (message) => {
+      const diagnostic = new AbortController();
+      const timer = setTimeout(() => diagnostic.abort(), Math.max(1, Math.min(limits.timeoutMs, deadline - Date.now())));
+      try {
+        await writeDiagnostic(context.stderr, `${dialect.name}: ${message.slice(0, 4096)}
+`, AbortSignal.any([context.signal, diagnostic.signal]));
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (!diagnostic.signal.aborted) throw error;
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+    let parsed;
+    try {
+      parsed = dialect.invocation(context.args);
+    } catch (error) {
+      await diagnose(publicDiagnosticMessage(error, context.onInternalError));
+      return { exitCode: 2 };
+    }
+    context.signal.throwIfAborted();
+    if (parsed.help) {
+      await writeBytes(context.stdout, import_buffer.Buffer.from(dialect.help), context.signal);
+      return { exitCode: 0 };
+    }
+    if (!runtime) {
+      await diagnose("runtime not installed; inject run, createBudget, makeFsModule and declareHostOperation");
+      return { exitCode: 127 };
+    }
+    const controller = new AbortController();
+    const signal = AbortSignal.any([context.signal, controller.signal]);
+    let failure;
+    let hasFailure = false;
+    const fail = (error) => {
+      if (!hasFailure && !controller.signal.aborted) {
+        hasFailure = true;
+        failure = error;
+        queueMicrotask(() => controller.abort(error));
+      }
+    };
+    const timeout = setTimeout(() => fail(new SafeJsCommandLimitError("timeoutMs")), limits.timeoutMs);
+    let input;
+    const output = new GuestOutput(context.stdout, context.stderr, limits.maxOutputBytes, signal, fail);
+    let exitCode = 0;
+    let thrown;
+    let failed = false;
+    try {
+      const fromStdin = parsed.source === void 0 && parsed.file === "-";
+      let source = parsed.source;
+      let filename = parsed.file;
+      if (source === void 0) {
+        if (!fromStdin) filename = pathOf(context, parsed.file);
+        const capabilities = fromStdin ? void 0 : await withSignal(signal, async () => await context.fs.capabilitiesFor?.(filename, { signal }) ?? context.fs.capabilities);
+        const bytes = fromStdin ? context.stdin : context.fs.readStream && capabilities?.streamingRead !== false ? context.fs.readStream(filename, { signal, chunkSize: 65536 }) : toByteSource(await withSignal(signal, () => context.fs.readFile(filename, { signal, maxBytes: limits.maxSourceBytes })));
+        const reader = new GuestInput(bytes, limits.maxSourceBytes, signal, fail, "maxSourceBytes");
+        try {
+          source = await reader.readText();
+        } finally {
+          await reader.close();
+        }
+      } else if (import_buffer.Buffer.byteLength(source) > limits.maxSourceBytes) throw new SafeJsCommandLimitError("maxSourceBytes");
+      if (source.startsWith("\uFEFF")) source = source.slice(1);
+      input = new GuestInput(fromStdin ? toByteSource("") : context.stdin, limits.maxInputBytes, signal, fail);
+      const guestInput = input;
+      const declare = runtime.declareHostOperation;
+      const stdio = {
+        readBytes: declare(async (size) => guestInput.readBytes(size), "read-side-effect"),
+        readText: declare(async () => guestInput.readText(), "read-side-effect"),
+        write: declare(async (text) => output.text(text), "read-side-effect"),
+        writeBytes: declare(async (bytes) => output.bytes(bytes), "read-side-effect"),
+        error: declare(async (text) => output.text(text, true), "read-side-effect"),
+        errorBytes: declare(async (bytes) => output.bytes(bytes, true), "read-side-effect")
+      };
+      const env = /* @__PURE__ */ Object.create(null);
+      for (const [key, value] of Object.entries(context.env)) env[key] = value;
+      const command = {
+        args: [...parsed.args],
+        cwd: context.cwd,
+        env,
+        setExitCode: declare((value) => {
+          signal.throwIfAborted();
+          if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 255) throw new TypeError("exit code must be an integer from 0 through 255");
+          exitCode = value;
+        }, "read-side-effect")
+      };
+      const budget = runtime.createBudget({
+        maxSteps: limits.maxSteps,
+        deadline,
+        maxCallDepth: limits.maxCallDepth,
+        stringLength: limits.stringLength,
+        arrayLength: limits.arrayLength,
+        dataSize: limits.dataSize
+      });
+      const modules = { fs: makeSafeJsFsModule(runtime.makeFsModule, context.fs, { cwd: context.cwd, signal }), stdio, command };
+      const prepared = dialect.prepare?.(source, { ...parsed, file: filename }, modules);
+      const result = record(await withSignal(signal, () => runtime.run(prepared?.source ?? source, {
+        budget,
+        filename,
+        modules,
+        signal,
+        ...prepared ? { bindings: prepared.bindings } : {},
+        sink: { log: (...args) => output.console(args, false), error: (...args) => output.console(args, true) }
+      })), "SafeJS run result");
+      signal.throwIfAborted();
+      if (result.ok !== true && result.ok !== false) throw new TypeError("Invalid SafeJS run result.ok");
+      if (!result.ok) {
+        const info = errorInfo(result.error);
+        throw new GuestDiagnostic(info);
+      }
+      if (parsed.print && result.returnValue !== void 0) await output.result(result.returnValue);
+      await output.drain();
+    } catch (error) {
+      thrown = hasFailure ? failure : error;
+      failed = true;
+    } finally {
+      try {
+        await output.drain();
+      } catch (error) {
+        thrown = hasFailure ? failure : error;
+        failed = true;
+      }
+      controller.abort();
+      clearTimeout(timeout);
+      await input?.close().catch(() => {
+      });
+    }
+    context.signal.throwIfAborted();
+    if (failed) {
+      const info = thrown instanceof GuestDiagnostic ? thrown.info : { name: statusField(thrown, "name"), code: statusField(thrown, "code") };
+      const detail = thrown instanceof SafeJsCommandLimitError ? thrown.message : publicDiagnosticMessage(thrown, context.onInternalError);
+      if (!output.stderrFailed) await diagnose(detail);
+      return { exitCode: thrown instanceof SafeJsCommandLimitError || info.code === "budgetExceeded" ? 124 : thrown instanceof UsageError || info.name === "ParseError" ? 2 : 1 };
+    }
+    return { exitCode };
+  } }];
+}
+
+// packages/safe-bash/src/commands/node/safejs.ts
+function createSafeJsNodeCommands(options) {
+  const settings = record(options, "node options");
+  onlyKeys(settings, ["runtime", "limits", "replace"]);
+  if (Object.hasOwn(settings, "replace") && typeof settings.replace !== "boolean") throw new TypeError("node replace must be boolean");
+  delete settings.replace;
+  return Object.freeze([createSafeJsNodeCommand(settings)]);
+}
+function safeJsNodeCommands(options) {
+  const definitions = createSafeJsNodeCommands(options);
+  const replace = options.replace ?? false;
+  return { name: "node-commands", setup(host) {
+    if (!replace && host.commands.has("node")) throw new Error("Command already registered: node");
+    for (const definition of definitions) host.commands.register(definition, { replace });
+  } };
+}
+function invocation(args) {
+  let source;
+  let print = false;
+  let index = 0;
+  for (; index < args.length; index++) {
+    const argument = args[index];
+    if (argument === "--") {
+      index++;
+      break;
+    }
+    if (argument === "-h" || argument === "--help") return { file: "-", args: [], print: false, help: true };
+    if (argument === "--input-type" || argument.startsWith("--input-type=")) {
+      const value = argument === "--input-type" ? args[++index] : argument.slice(13);
+      if (value !== "module") throw new UsageError("SafeJS node supports only --input-type=module");
+      continue;
+    }
+    const mode = argument === "--eval" || argument.startsWith("--eval=") || argument.startsWith("-e") ? "eval" : argument === "--print" || argument.startsWith("--print=") || argument.startsWith("-p") ? "print" : void 0;
+    if (mode) {
+      if (source !== void 0) throw new UsageError("conflicting source selectors");
+      print = mode === "print";
+      const equal = argument.indexOf("=");
+      source = argument.startsWith("--") ? equal >= 0 ? argument.slice(equal + 1) : args[++index] : argument.length > 2 ? argument.slice(2) : args[++index];
+      if (source === void 0) throw new UsageError(`${argument} requires JavaScript source`);
+      continue;
+    }
+    if (argument !== "-" && argument.startsWith("-")) throw new UsageError(`unsupported node option '${argument}'`);
+    break;
+  }
+  if (source !== void 0) return { source, file: print ? "<node -p>" : "<node -e>", args: args.slice(index), print, help: false };
+  return { file: args[index] ?? "-", args: args.slice(index + 1), print: false, help: false };
+}
+function createSafeJsNodeCommand(options) {
+  const settings = record(options, "node options");
+  onlyKeys(settings, ["runtime", "limits"]);
+  if (settings.runtime === void 0 || settings.runtime === null) throw new TypeError("node requires an injected SafeJS runtime");
+  options = settings;
+  const definitions = createSafeJsCommands(options, {
+    name: "node",
+    description: "Execute JavaScript with an injected SafeJS runtime and virtual I/O",
+    help: 'Usage: node [-e SOURCE | -p EXPRESSION | FILE | -] [ARG...]\nExecutes with the injected SafeJS interpreter; no native Node.js process.\nSupports --eval, --print, --input-type=module and -- before operands.\nNo source operand reads stdin. Files and inline source leave stdin for guest data.\nUse async imports from fs or require("node:fs/promises").\nNative modules, synchronous fs and local module loading are not supported.\n',
+    invocation,
+    prepare(source, selected, modules) {
+      const command = modules.command;
+      const stdio = modules.stdio;
+      const fs = modules.fs;
+      const processModule = {
+        argv: ["/virtual/bin/node", ...selected.source === void 0 ? [selected.file] : [], ...selected.args],
+        env: command.env,
+        cwd: options.runtime.declareHostOperation(() => command.cwd, "read-side-effect"),
+        exitCode: 0,
+        stdin: { readText: stdio.readText, readBytes: stdio.readBytes },
+        stdout: { write: stdio.write },
+        stderr: { write: stdio.error }
+      };
+      modules.fs = { ...fs, default: fs };
+      const requiredModules = /* @__PURE__ */ new Map([["fs/promises", fs], ["node:fs/promises", fs]]);
+      return {
+        source: (selected.print ? `console.log((
+${source}
+));` : source) + "\n;__safeBashSetExitCode(process.exitCode);",
+        bindings: {
+          process: processModule,
+          __safeBashSetExitCode: command.setExitCode,
+          require: options.runtime.declareHostOperation((name) => {
+            const module = typeof name === "string" ? requiredModules.get(name) : void 0;
+            if (!module) throw new TypeError("Unsupported node module; use fs/promises or node:fs/promises");
+            return module;
+          }, "read-side-effect")
+        }
+      };
+    }
+  });
+  return Object.freeze(definitions[0]);
+}
+
+export {
+  makeSafeJsShellModule,
+  SafeJsCommandLimitError,
+  defaultSafeJsLimits,
+  createSafeJsNodeCommands,
+  safeJsNodeCommands,
+  createSafeJsNodeCommand
+};
+//# sourceMappingURL=chunk-3BZ5NQ73.js.map