@poe-platform/safe-js 0.1.0

package/dist/safe-js/browser/chunks/chunk-QGN6DKT5.js

@@ -0,0 +1,4335 @@
+// packages/safe-fs/src/platform/browser.ts
+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);
+    }
+  }
+});
+
+// packages/safe-fs/src/contracts/errors.ts
+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",
+  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);
+}
+function toFsError(error, options = {}) {
+  if (error instanceof FsError && Object.keys(options).length === 0) return error;
+  const source = typeof error === "object" && error !== null ? error : {};
+  const details = {
+    ...typeof source.syscall === "string" ? { syscall: source.syscall } : {},
+    ...typeof source.path === "string" ? { path: source.path } : {},
+    ...typeof source.dest === "string" ? { dest: source.dest } : {},
+    cause: error,
+    ...options
+  };
+  return new FsError(isErrnoCode(source.code) ? source.code : "EIO", details);
+}
+
+// packages/safe-fs/src/contracts/filesystem.ts
+var ACCESS_MODES = Object.freeze({ F_OK: 0, R_OK: 4, W_OK: 2, X_OK: 1 });
+
+// packages/safe-fs/src/contracts/cleanup.ts
+async function finishCleanup(cleanup, failed) {
+  try {
+    await cleanup();
+  } catch (error) {
+    if (!failed) throw error;
+  }
+}
+
+// packages/safe-fs/src/contracts/io.ts
+function toByteSource(input) {
+  if (typeof input !== "string" && !(input instanceof Uint8Array)) {
+    throw new TypeError("Byte source input must be a string or Uint8Array");
+  }
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : new Uint8Array(input);
+  return (async function* () {
+    if (bytes.byteLength > 0) yield bytes;
+  })();
+}
+async function collectBytes(source, options) {
+  if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0) {
+    throw new RangeError("maxBytes must be a nonnegative safe integer");
+  }
+  const chunks = [];
+  let size = 0;
+  options.signal?.throwIfAborted();
+  for await (const chunk of readBytes(source, options.signal)) {
+    if (chunk.byteLength > options.maxBytes - size) {
+      throw new FsError("EFBIG", { syscall: "collectBytes", message: "output exceeds maxBytes" });
+    }
+    if (chunk.byteLength > 0) chunks.push(new Uint8Array(chunk));
+    size += chunk.byteLength;
+  }
+  options.signal?.throwIfAborted();
+  const result = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+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* readBytes(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);
+    }
+  }
+}
+
+// packages/safe-fs/src/contracts/virtual-path.ts
+function validatePath(path) {
+  if (typeof path !== "string" || path.includes("\0")) {
+    throw new FsError("EINVAL", { syscall: "resolve", message: "paths must be strings without NUL bytes" });
+  }
+}
+function resolvePath(cwd, ...paths) {
+  validatePath(cwd);
+  if (!cwd.startsWith("/")) throw new FsError("EINVAL", { syscall: "resolve", path: cwd, message: "cwd must be absolute" });
+  for (const path of paths) validatePath(path);
+  const components = [];
+  for (const path of [cwd, ...paths]) {
+    if (path.startsWith("/")) components.length = 0;
+    for (const component of path.split("/")) {
+      if (component === "" || component === ".") continue;
+      if (component === "..") components.pop();
+      else components.push(component);
+    }
+  }
+  return `/${components.join("/")}`;
+}
+function normalizePath(path, cwd = "/") {
+  return resolvePath(cwd, path);
+}
+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 relativePath(from, to) {
+  const source = normalizePath(from).split("/").filter(Boolean);
+  const target = normalizePath(to).split("/").filter(Boolean);
+  let common = 0;
+  while (common < source.length && common < target.length && source[common] === target[common]) common++;
+  return [...Array(source.length - common).fill(".."), ...target.slice(common)].join("/");
+}
+function isPathWithin(root, path) {
+  const normalizedRoot = normalizePath(root);
+  const normalizedPath = normalizePath(path);
+  return normalizedRoot === "/" || normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+function assertPathWithin(root, path) {
+  const normalizedPath = normalizePath(path);
+  if (!isPathWithin(root, normalizedPath)) throw new FsError("EACCES", { syscall: "resolve", path, message: "path escapes the allowed root" });
+  return normalizedPath;
+}
+
+// packages/safe-fs/src/contracts/portable-path.ts
+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 components = [];
+  for (const component of joined.split("/")) {
+    if (!component || component === ".") continue;
+    if (component === "..") {
+      if (components.length && components.at(-1) !== "..") components.pop();
+      else if (!absolute) components.push(component);
+    } else components.push(component);
+  }
+  const result = `${absolute ? "/" : ""}${components.join("/")}` || ".";
+  return joined.endsWith("/") && result !== "/" ? `${result}/` : result;
+}
+var posixPath = Object.freeze({ basename, dirname: dirname2, extname, join: joinPath, isAbsolute: isAbsolutePath });
+
+// packages/safe-fs/src/fs/mount/identity.ts
+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";
+}
+
+// packages/safe-fs/src/fs/mount/comparison.ts
+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 registerEntryView(filesystem, resolver) {
+  if (resolvers.has(filesystem)) throw new TypeError("entry view already registered");
+  resolvers.set(filesystem, resolver);
+}
+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);
+}
+
+// packages/safe-fs/src/fs/s3/registry.ts
+var entries = /* @__PURE__ */ new WeakMap();
+function getOwnedS3Entry(view) {
+  return entries.get(view.filesystem)?.(view);
+}
+
+// packages/safe-fs/src/fs/webdav/resource-id.ts
+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";
+}
+
+// packages/safe-fs/src/fs/memory/index.ts
+var typeModes = { file: 32768, directory: 16384, symlink: 40960 };
+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 {
+  capabilities = Object.freeze({
+    readOnly: false,
+    symlinks: true,
+    hardlinks: true,
+    permissions: true,
+    timestamps: true,
+    atomicRename: true,
+    streamingRead: true,
+    streamingWrite: true
+  });
+  identityScope = /* @__PURE__ */ Symbol();
+  nextInode = 1;
+  root = this.directory(493);
+  constructor() {
+    const root = this.root;
+    ownedStores.set(this, {
+      root,
+      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);
+  }
+  metadata(mode2) {
+    const now = Date.now();
+    return {
+      mode: mode2,
+      ino: this.nextInode++,
+      nlink: 1,
+      atimeMs: now,
+      mtimeMs: now,
+      ctimeMs: now,
+      birthtimeMs: now
+    };
+  }
+  directory(mode2) {
+    return { ...this.metadata(typeModes.directory | mode2), type: "directory", entries: /* @__PURE__ */ new Map() };
+  }
+  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.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);
+      this.permission(current, 1, syscall, path);
+      if (component === ".") continue;
+      if (component === "..") {
+        if (stack.length > 1) stack.pop();
+        continue;
+      }
+      if (new TextEncoder().encode(component).byteLength > 255) this.fail("ENAMETOOLONG", syscall, path);
+      let node = current.entries.get(component);
+      if (!node && options.createDirectories !== void 0) {
+        this.permission(current, 3, syscall, path);
+        node = this.directory(options.createDirectories);
+        current.entries.set(component, node);
+        this.changed(current);
+      }
+      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(".");
+        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,
+      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" ? 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) {
+    if (!(data instanceof Uint8Array)) throw new TypeError("Memory files require Uint8Array data");
+    return new Uint8Array(data);
+  }
+  allocate(length, syscall, path) {
+    try {
+      return new Uint8Array(length);
+    } catch (cause) {
+      throw new FsError("EFBIG", { syscall, path, cause });
+    }
+  }
+  openWrite(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);
+      return location.node;
+    }
+    this.permission(location.parent, 3, syscall, path);
+    const node = { ...this.metadata(typeModes.file | mode2), type: "file", data: new Uint8Array() };
+    location.parent.entries.set(location.name, node);
+    this.changed(location.parent);
+    return node;
+  }
+  append(node, data, syscall, path) {
+    const length = node.data.byteLength + data.byteLength;
+    let storage;
+    if (length <= node.data.buffer.byteLength) {
+      storage = new Uint8Array(node.data.buffer);
+    } else {
+      storage = this.allocate(Math.max(length, node.data.byteLength * 2, 64), syscall, path);
+      storage.set(node.data);
+    }
+    storage.set(data, node.data.byteLength);
+    node.data = storage.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);
+  }
+  async writeFile(path, data, options = {}) {
+    options.signal?.throwIfAborted();
+    const copied = this.bytes(data);
+    const node = this.openWrite(path, options, "writeFile");
+    if (options.flag === "a" || options.flag === "ax") this.append(node, copied, "writeFile", path);
+    else {
+      node.data = copied;
+      this.changed(node);
+    }
+  }
+  async appendFile(path, data, options = {}) {
+    options.signal?.throwIfAborted();
+    const copied = this.bytes(data);
+    this.append(this.openWrite(path, { ...options, flag: "a" }, "appendFile"), copied, "appendFile", path);
+  }
+  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 = {}) {
+    options.signal?.throwIfAborted();
+    const node = this.resolve(path, "readdir").node;
+    if (node.type !== "directory") this.fail("ENOTDIR", "readdir", path);
+    this.permission(node, 4, "readdir", 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);
+    location.parent.entries.set(location.name, this.directory(mode2));
+    this.changed(location.parent);
+  }
+  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);
+    node.nlink = 0;
+    node.ctimeMs = Date.now();
+    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);
+    for (const entry of removed) {
+      entry.nlink--;
+      entry.ctimeMs = Date.now();
+    }
+    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 (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);
+        target.node.nlink--;
+        target.node.ctimeMs = Date.now();
+      }
+      origin.parent.entries.delete(origin.name);
+      target.parent.entries.set(target.name, node);
+      this.changed(origin.parent);
+      this.changed(target.parent);
+      node.ctimeMs = Date.now();
+    } 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.openWrite(destination, { mode: origin.mode & 4095, flag: options.exclusive ? "wx" : "w" }, "copyFile");
+      node.data = new Uint8Array(origin.data);
+      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);
+    location.parent.entries.set(location.name, { ...this.metadata(typeModes.symlink | 511), type: "symlink", target });
+    this.changed(location.parent);
+  }
+  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);
+    target.parent.entries.set(target.name, node);
+    node.nlink++;
+    node.ctimeMs = Date.now();
+    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();
+  }
+  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();
+  }
+  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);
+    const data = this.allocate(length, "truncate", path);
+    data.set(node.data.subarray(0, length));
+    node.data = data;
+    this.changed(node);
+  }
+  async *readStream(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const start = options.start ?? 0;
+    const chunkSize = options.chunkSize ?? 64 * 1024;
+    this.integer(start, "readStream", path);
+    this.integer(chunkSize, "readStream", path);
+    if (chunkSize === 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);
+    const data = node.data;
+    const end = Math.min(options.endExclusive ?? data.byteLength, data.byteLength);
+    node.atimeMs = Date.now();
+    for (let offset = start; offset < end; offset += chunkSize) {
+      options.signal?.throwIfAborted();
+      yield data.slice(offset, Math.min(offset + chunkSize, end));
+    }
+    options.signal?.throwIfAborted();
+  }
+  async writeStream(path, source, options = {}) {
+    options.signal?.throwIfAborted();
+    const node = this.openWrite(path, options, "writeStream");
+    if (options.flag !== "a" && options.flag !== "ax") {
+      node.data = new Uint8Array();
+      this.changed(node);
+    }
+    for await (const chunk of source) {
+      options.signal?.throwIfAborted();
+      this.append(node, this.bytes(chunk), "writeStream", path);
+    }
+    options.signal?.throwIfAborted();
+  }
+};
+var memoryImplementation = Object.getOwnPropertyDescriptors(MemoryFileSystem.prototype);
+function createMemoryFileSystem() {
+  return new MemoryFileSystem();
+}
+
+// packages/safe-fs/src/fs/readonly/index.ts
+function readOnly(syscall, path, dest) {
+  throw new FsError("EROFS", { syscall, path, ...dest === void 0 ? {} : { dest } });
+}
+function snapshotStat(stat) {
+  const { type, size, allocatedBytes, mode: mode2, mtimeMs, atimeMs, ctimeMs, birthtimeMs, identityScope, ino, dev, nlink, uid, gid } = stat;
+  return {
+    type,
+    size,
+    mode: mode2,
+    mtimeMs,
+    atimeMs,
+    ctimeMs,
+    ...allocatedBytes === void 0 ? {} : { allocatedBytes },
+    ...birthtimeMs === void 0 ? {} : { birthtimeMs },
+    ...identityScope === void 0 ? {} : { identityScope },
+    ...ino === void 0 ? {} : { ino },
+    ...dev === void 0 ? {} : { dev },
+    ...nlink === void 0 ? {} : { nlink },
+    ...uid === void 0 ? {} : { uid },
+    ...gid === void 0 ? {} : { gid }
+  };
+}
+var ReadOnlyFileSystem = class {
+  #filesystem;
+  #capabilities;
+  constructor(filesystem) {
+    this.#filesystem = filesystem;
+    registerEntryView(this, async (path) => ({ filesystem: this.#filesystem, path, readOnly: true }));
+    const streamingRead = typeof filesystem.readStream === "function" ? filesystem.capabilities.streamingRead : false;
+    this.#capabilities = Object.freeze({
+      readOnly: true,
+      symlinks: filesystem.capabilities.symlinks === true && typeof filesystem.readlink === "function",
+      hardlinks: false,
+      permissions: false,
+      timestamps: false,
+      atomicRename: false,
+      ...streamingRead === void 0 ? {} : { streamingRead },
+      streamingWrite: false
+    });
+  }
+  get capabilities() {
+    return this.#capabilities;
+  }
+  async readFile(path, options) {
+    return new Uint8Array(await this.#filesystem.readFile(path, options));
+  }
+  async stat(path, options) {
+    return snapshotStat(await this.#filesystem.stat(path, options));
+  }
+  async lstat(path, options) {
+    return snapshotStat(await this.#filesystem.lstat(path, options));
+  }
+  compareEntry(path, peer, peerPath, options = {}) {
+    return compareEntries(this, path, peer, peerPath, options);
+  }
+  async readdir(path, options) {
+    return (await this.#filesystem.readdir(path, options)).map((entry) => ({ name: entry.name, type: entry.type }));
+  }
+  async realpath(path, options) {
+    return this.#filesystem.realpath(path, options);
+  }
+  async access(path, mode2 = ACCESS_MODES.F_OK, options) {
+    if (!Number.isInteger(mode2) || mode2 < 0 || mode2 > 7) {
+      throw new FsError("EINVAL", { syscall: "access", path });
+    }
+    if ((mode2 & ACCESS_MODES.W_OK) !== 0) readOnly("access", path);
+    return this.#filesystem.access(path, mode2, options);
+  }
+  async readlink(path, options) {
+    if (typeof this.#filesystem.readlink !== "function") {
+      throw new FsError("ENOTSUP", { syscall: "readlink", path });
+    }
+    return this.#filesystem.readlink(path, options);
+  }
+  async *readStream(path, options) {
+    if (typeof this.#filesystem.readStream !== "function") {
+      throw new FsError("ENOTSUP", { syscall: "readStream", path });
+    }
+    for await (const chunk of readBytes(this.#filesystem.readStream(path, options), options?.signal)) {
+      yield new Uint8Array(chunk);
+    }
+  }
+  async writeFile(path, _data, _options) {
+    readOnly("writeFile", path);
+  }
+  async appendFile(path, _data, _options) {
+    readOnly("appendFile", path);
+  }
+  async writeStream(path, _source, _options) {
+    readOnly("writeStream", path);
+  }
+  async mkdir(path, _options) {
+    readOnly("mkdir", path);
+  }
+  async rm(path, _options) {
+    readOnly("rm", path);
+  }
+  async unlink(path, _options) {
+    readOnly("unlink", path);
+  }
+  async rmdir(path, _options) {
+    readOnly("rmdir", path);
+  }
+  async rename(source, destination, _options) {
+    readOnly("rename", source, destination);
+  }
+  async copyFile(source, destination, _options) {
+    readOnly("copyFile", source, destination);
+  }
+  async symlink(target, path, _options) {
+    readOnly("symlink", target, path);
+  }
+  async link(existingPath, newPath, _options) {
+    readOnly("link", existingPath, newPath);
+  }
+  async chmod(path, _mode, _options) {
+    readOnly("chmod", path);
+  }
+  async utimes(path, _atimeMs, _mtimeMs, _options) {
+    readOnly("utimes", path);
+  }
+  async truncate(path, _length, _options) {
+    readOnly("truncate", path);
+  }
+};
+function createReadOnlyFileSystem(filesystem) {
+  return new ReadOnlyFileSystem(filesystem);
+}
+
+// packages/safe-fs/src/fs/mount/index.ts
+var syntheticStat = Object.freeze({
+  type: "directory",
+  size: 0,
+  mode: 16749,
+  mtimeMs: 0,
+  atimeMs: 0,
+  ctimeMs: 0
+});
+function within(parent, path) {
+  return parent === "/" || path === parent || path.startsWith(`${parent}/`);
+}
+function globalPath(path) {
+  return typeof path === "string" && path.startsWith("/") ? path : `/${String(path)}`;
+}
+function fail(code) {
+  throw new FsError(code);
+}
+function snapshotStat2(stat) {
+  const { type, size, allocatedBytes, mode: mode2, mtimeMs, atimeMs, ctimeMs, birthtimeMs, identityScope, ino, dev, nlink, uid, gid } = stat;
+  return {
+    type,
+    size,
+    mode: mode2,
+    mtimeMs,
+    atimeMs,
+    ctimeMs,
+    ...allocatedBytes === void 0 ? {} : { allocatedBytes },
+    ...birthtimeMs === void 0 ? {} : { birthtimeMs },
+    ...identityScope === void 0 ? {} : { identityScope },
+    ...ino === void 0 ? {} : { ino },
+    ...dev === void 0 ? {} : { dev },
+    ...nlink === void 0 ? {} : { nlink },
+    ...uid === void 0 ? {} : { uid },
+    ...gid === void 0 ? {} : { gid }
+  };
+}
+var MountFileSystem = class _MountFileSystem {
+  capabilities;
+  mounts;
+  constructor(options) {
+    const mounts = [];
+    const paths = /* @__PURE__ */ new Set();
+    const add = (path, backend) => {
+      if (backend instanceof _MountFileSystem) {
+        for (const child of backend.mounts) {
+          add(path === "/" ? child.path : child.path === "/" ? path : `${path}${child.path}`, child.backend);
+        }
+        return;
+      }
+      if (paths.has(path)) {
+        throw new FsError("EINVAL", { syscall: "mount", path });
+      }
+      paths.add(path);
+      mounts.push({ path, backend });
+    };
+    add("/", options.root);
+    for (const [input, backend] of Object.entries(options.mounts ?? {})) {
+      try {
+        validatePath(input);
+      } catch (error) {
+        throw new FsError("EINVAL", { syscall: "mount", path: globalPath(input), cause: error });
+      }
+      const path = normalizePath(input);
+      if (!input.startsWith("/") || path === "/") {
+        throw new FsError("EINVAL", { syscall: "mount", path: globalPath(input) });
+      }
+      add(path, backend);
+    }
+    this.mounts = mounts.sort((left, right) => right.path.length - left.path.length);
+    registerEntryView(this, (path, options2) => this.operation("compareEntry", path, options2, async () => {
+      const location = await this.resolve(path, options2);
+      if (location.synthetic) return { filesystem: this, path, stat: syntheticStat, readOnly: true };
+      return { filesystem: location.mount.backend, path: location.local };
+    }));
+    registerEntryAuthority(this, async () => "unknown");
+    const all = (capability, methods = []) => mounts.every(({ backend }) => backend.capabilities[capability] === true && methods.every((method) => typeof backend[method] === "function"));
+    const streaming = (capability, method) => all(capability, [method]) ? true : mounts.some(({ backend }) => backend.capabilities[capability] !== false && typeof backend[method] === "function") ? void 0 : false;
+    const streamingRead = streaming("streamingRead", "readStream");
+    const streamingWrite = streaming("streamingWrite", "writeStream");
+    this.capabilities = Object.freeze({
+      get snapshotRmdir() {
+        return mounts.some(({ backend }) => backend.capabilities.snapshotRmdir === true);
+      },
+      readOnly: all("readOnly"),
+      symlinks: all("symlinks", ["readlink", "symlink"]),
+      hardlinks: all("hardlinks", ["link"]),
+      permissions: all("permissions", ["chmod"]),
+      timestamps: all("timestamps", ["utimes"]),
+      atomicRename: mounts.length === 1 && all("atomicRename"),
+      ...streamingRead === void 0 ? {} : { streamingRead },
+      ...streamingWrite === void 0 ? {} : { streamingWrite }
+    });
+  }
+  select(path) {
+    return this.mounts.find((mount) => within(mount.path, path));
+  }
+  protected(path) {
+    return path === "/" || this.mounts.some((mount) => within(path, mount.path));
+  }
+  error(error, syscall, path, options, dest) {
+    if (options.signal?.aborted && error === options.signal.reason) return error;
+    return new FsError(toFsError(error).code, {
+      cause: error,
+      syscall,
+      path: globalPath(path),
+      ...dest === void 0 ? {} : { dest: globalPath(dest) }
+    });
+  }
+  async operation(syscall, path, options, action, dest) {
+    try {
+      options.signal?.throwIfAborted();
+      const result = await action();
+      options.signal?.throwIfAborted();
+      return result;
+    } catch (error) {
+      throw this.error(error, syscall, path, options, dest);
+    }
+  }
+  components(path) {
+    validatePath(path);
+    if (!path) fail("ENOENT");
+    const parts = path.split("/").filter(Boolean).map((name) => ({ name }));
+    if (path.endsWith("/")) parts.push({ name: ".", trailing: true });
+    return parts;
+  }
+  async lookup(path, options, parent, plannedParent = false) {
+    options.signal?.throwIfAborted();
+    const mount = this.select(path);
+    const local = mount.path === "/" ? path : path.slice(mount.path.length) || "/";
+    let stat;
+    if (!parent?.synthetic && !plannedParent || parent?.mount !== mount) {
+      try {
+        stat = await mount.backend.lstat(local, options);
+      } catch (error) {
+        if (toFsError(error).code !== "ENOENT") throw error;
+      }
+    }
+    options.signal?.throwIfAborted();
+    if (path === mount.path && stat?.type !== "directory") fail(stat ? "ENOTDIR" : "ENOENT");
+    const synthetic = this.protected(path) && stat?.type !== "directory";
+    return { path, mount, local, stat: synthetic ? syntheticStat : stat, synthetic };
+  }
+  async resolve(path, options, settings = {}) {
+    let pending = this.components(path);
+    const stack = [await this.lookup("/", options)];
+    let boundary;
+    let verification;
+    const verified = async (location) => {
+      if (verification) {
+        const canonical = await verification.mount.backend.realpath(verification.path, options);
+        validatePath(canonical);
+        if (!canonical.startsWith("/") || normalizePath(canonical) !== canonical) fail("EIO");
+        if (verification.finalName !== void 0) {
+          try {
+            await verification.mount.backend.lstat(`${verification.path}/${verification.finalName}`, options);
+          } catch (error) {
+            if (location.stat || toFsError(error).code !== "ENOENT") throw error;
+          }
+        }
+        const expected = verification.finalName === void 0 ? canonical : `${canonical === "/" ? "" : canonical}/${verification.finalName}`;
+        if (location.mount !== verification.mount || location.local !== expected) fail("ENOTSUP");
+      }
+      return location;
+    };
+    let links = 0;
+    while (pending.length > 0) {
+      options.signal?.throwIfAborted();
+      const component = pending.shift();
+      const current = stack[stack.length - 1];
+      if (current.stat?.type !== "directory") fail("ENOTDIR");
+      if (!current.synthetic && !settings.createDirectories?.has(current.path)) {
+        const mode2 = current.mount.backend.capabilities.permissions === false ? 0 : 1;
+        await current.mount.backend.access(current.local, mode2, options);
+      }
+      if (component.name === ".") continue;
+      if (component.name === "..") {
+        if (boundary && current.path === boundary.path) fail("EACCES");
+        if (stack.length > 1) stack.pop();
+        if (boundary && stack[stack.length - 1].mount !== boundary) fail("EACCES");
+        continue;
+      }
+      const nextPath = `${current.path === "/" ? "" : current.path}/${component.name}`;
+      if (boundary && this.select(nextPath) !== boundary) fail("EACCES");
+      let next = settings.createDirectories?.get(nextPath) ?? await this.lookup(nextPath, options, current, settings.createDirectories?.has(current.path));
+      if (!next.stat) {
+        if (settings.createDirectories) {
+          if (current.synthetic) fail("ENOTSUP");
+          this.mutable(next);
+          next = { ...next, stat: syntheticStat };
+          settings.createDirectories.set(nextPath, next);
+        } else if (settings.allowMissing && (pending.length === 0 || settings.missingDirectory && pending.length === 1 && pending[0].trailing)) {
+          if (current.synthetic) fail("ENOTSUP");
+          return verified(next);
+        } else {
+          fail("ENOENT");
+        }
+      }
+      const final = pending.length === 0 || settings.entry && pending.length === 1 && pending[0].trailing;
+      if (next.stat?.type === "symlink" && (settings.followFinal !== false || !final)) {
+        if (++links > 40) fail("ELOOP");
+        boundary ??= next.mount;
+        if (boundary !== next.mount) fail("EACCES");
+        if (!verification) {
+          const suffix = pending.map((part) => part.name);
+          const last = suffix.at(-1);
+          const finalName = settings.followFinal === false && last !== void 0 && last !== "." && last !== ".." ? suffix.pop() : void 0;
+          verification = {
+            mount: next.mount,
+            path: `${next.local}${suffix.length === 0 ? "" : `/${suffix.join("/")}`}`,
+            finalName
+          };
+        }
+        const readlink = this.optional(next, "readlink", "symlinks");
+        const target = await readlink.call(next.mount.backend, next.local, options);
+        const targetParts = this.components(target);
+        if (target.startsWith("/")) {
+          const rootIndex = stack.findIndex((entry) => entry.path === next.mount.path);
+          if (rootIndex < 0) fail("EACCES");
+          stack.splice(rootIndex + 1);
+        }
+        pending = [...targetParts, ...pending];
+      } else {
+        stack.push(next);
+      }
+    }
+    return verified(stack[stack.length - 1]);
+  }
+  mutable(location) {
+    if (this.protected(location.path)) fail("EBUSY");
+    if (location.mount.backend.capabilities.readOnly) fail("EROFS");
+  }
+  entryPath(path) {
+    const terminal = path.split("/").filter(Boolean).at(-1);
+    if (terminal === "." || terminal === "..") fail("EINVAL");
+  }
+  optional(location, method, capability) {
+    const backend = location.mount.backend;
+    const implementation = backend[method];
+    if (!implementation || capability && backend.capabilities[capability] === false) fail("ENOTSUP");
+    return implementation;
+  }
+  readFile(path, options = {}) {
+    return this.operation("readFile", path, options, async () => {
+      const location = await this.resolve(path, options);
+      if (location.synthetic) fail("EISDIR");
+      return location.mount.backend.readFile(location.local, options);
+    });
+  }
+  writeFile(path, data, options = {}) {
+    return this.operation("writeFile", path, options, async () => {
+      const location = await this.resolve(path, options, { allowMissing: true, followFinal: !options.flag?.endsWith("x") });
+      this.mutable(location);
+      await location.mount.backend.writeFile(location.local, data, options);
+    });
+  }
+  appendFile(path, data, options = {}) {
+    return this.operation("appendFile", path, options, async () => {
+      const location = await this.resolve(path, options, { allowMissing: true });
+      this.mutable(location);
+      await location.mount.backend.appendFile(location.local, data, options);
+    });
+  }
+  stat(path, options = {}) {
+    return this.operation("stat", path, options, async () => snapshotStat2((await this.resolve(path, options)).stat));
+  }
+  lstat(path, options = {}) {
+    return this.operation("lstat", path, options, async () => snapshotStat2((await this.resolve(path, options, { followFinal: false })).stat));
+  }
+  readdir(path, options = {}) {
+    return this.operation("readdir", path, options, async () => {
+      const location = await this.resolve(path, options);
+      if (location.stat?.type !== "directory") fail("ENOTDIR");
+      const entries2 = /* @__PURE__ */ new Map();
+      if (!location.synthetic) {
+        for (const entry of await location.mount.backend.readdir(location.local, options)) {
+          const { name, type } = entry;
+          if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0")) fail("EIO");
+          entries2.set(name, { name, type });
+        }
+      }
+      for (const mount of this.mounts) {
+        if (mount.path !== location.path && within(location.path, mount.path)) {
+          const suffix = mount.path.slice(location.path === "/" ? 1 : location.path.length + 1);
+          const name = suffix.split("/")[0];
+          entries2.set(name, { name, type: "directory" });
+        }
+      }
+      return [...entries2.values()].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+    });
+  }
+  mkdir(path, options = {}) {
+    return this.operation("mkdir", path, options, async () => {
+      const directories = /* @__PURE__ */ new Map();
+      const location = await this.resolve(path, options, options.recursive ? { createDirectories: directories } : { followFinal: false, allowMissing: true, missingDirectory: true, entry: true });
+      if (options.recursive) {
+        if (location.stat?.type !== "directory") fail("EEXIST");
+        for (const directory of directories.values()) {
+          options.signal?.throwIfAborted();
+          await directory.mount.backend.mkdir(directory.local, { ...options, recursive: false });
+        }
+        return;
+      }
+      this.mutable(location);
+      await location.mount.backend.mkdir(location.local, options);
+    });
+  }
+  rmdir(path, options = {}) {
+    return this.operation("rmdir", path, options, async () => {
+      const location = await this.resolve(path, options, { followFinal: false, entry: true });
+      this.mutable(location);
+      this.entryPath(path);
+      if (location.stat?.type !== "directory") fail("ENOTDIR");
+      const backend = location.mount.backend;
+      if (!backend.rmdir) fail("ENOTSUP");
+      options.signal?.throwIfAborted();
+      await backend.rmdir(location.local, options);
+    });
+  }
+  rm(path, options = {}) {
+    return this.operation("rm", path, options, async () => {
+      let location;
+      try {
+        location = await this.resolve(path, options, { followFinal: false, entry: true });
+      } catch (error) {
+        if (options.force && isFsError(error, "ENOENT")) return;
+        throw error;
+      }
+      this.mutable(location);
+      this.entryPath(path);
+      await location.mount.backend.rm(location.local, options);
+    });
+  }
+  rename(source, destination, options = {}) {
+    return this.operation("rename", source, options, async () => {
+      const origin = await this.resolve(source, options, { followFinal: false, entry: true });
+      const target = await this.resolve(destination, options, {
+        followFinal: false,
+        allowMissing: true,
+        entry: true,
+        missingDirectory: origin.stat?.type === "directory"
+      });
+      if (this.protected(origin.path) || this.protected(target.path)) fail("EBUSY");
+      if (origin.mount !== target.mount) fail("EXDEV");
+      this.mutable(origin);
+      this.mutable(target);
+      this.entryPath(source);
+      this.entryPath(destination);
+      await origin.mount.backend.rename(origin.local, target.local, options);
+    }, destination);
+  }
+  copyFile(source, destination, options = {}) {
+    return this.operation("copyFile", source, options, async () => {
+      const origin = await this.resolve(source, options);
+      if (origin.stat?.type === "directory") fail("EISDIR");
+      const target = await this.resolve(destination, options, { allowMissing: true, followFinal: !options.exclusive });
+      if (this.protected(target.path)) fail("EBUSY");
+      this.mutable(target);
+      if (options.exclusive && target.stat) fail("EEXIST");
+      if (origin.mount.backend === target.mount.backend && origin.local === target.local) fail("EINVAL");
+      let identity = compareIdentity(origin.stat, target.stat);
+      if (identity === "same") fail("EINVAL");
+      if (target.stat?.type === "directory") fail("EISDIR");
+      if (target.stat && identity === "unknown") {
+        identity = await compareEntries(origin.mount.backend, origin.local, target.mount.backend, target.local, options);
+        if (identity === "same") fail("EINVAL");
+      }
+      if (target.stat && identity === "unknown") fail("ENOTSUP");
+      if (origin.mount.backend === target.mount.backend) {
+        await origin.mount.backend.copyFile(origin.local, target.local, { ...options, exclusive: options.exclusive || !target.stat });
+        return;
+      }
+      const reader = origin.mount.backend;
+      const writer = target.mount.backend;
+      const writeOptions = {
+        ...options.signal ? { signal: options.signal } : {},
+        flag: options.exclusive || !target.stat ? "wx" : "w",
+        ...writer.capabilities.permissions === true ? { mode: origin.stat.mode & 4095 } : {}
+      };
+      if (reader.readStream && reader.capabilities.streamingRead !== false && writer.writeStream && writer.capabilities.streamingWrite !== false) {
+        const source2 = readBytes(reader.readStream(origin.local, options), options.signal);
+        let failed = false;
+        try {
+          await writer.writeStream(target.local, source2, writeOptions);
+        } catch (error) {
+          failed = true;
+          throw error;
+        } finally {
+          await finishCleanup(() => source2.return(void 0), failed);
+        }
+      } else {
+        const maxBytes = 64 * 1024 * 1024;
+        const data = await reader.readFile(origin.local, { ...options, maxBytes });
+        if (data.byteLength > maxBytes) fail("EFBIG");
+        options.signal?.throwIfAborted();
+        await writer.writeFile(target.local, data, writeOptions);
+      }
+    }, destination);
+  }
+  realpath(path, options = {}) {
+    return this.operation("realpath", path, options, async () => (await this.resolve(path, options)).path);
+  }
+  compareEntry(path, peer, peerPath, options = {}) {
+    return this.operation("compareEntry", path, options, () => compareEntries(this, path, peer, peerPath, options), peerPath);
+  }
+  access(path, mode2 = 0, options = {}) {
+    return this.operation("access", path, options, async () => {
+      if (!Number.isInteger(mode2) || mode2 < 0 || mode2 > 7) fail("EINVAL");
+      const location = await this.resolve(path, options);
+      if (location.synthetic) {
+        if (mode2 & 2) fail("EACCES");
+      } else {
+        await location.mount.backend.access(location.local, mode2, options);
+      }
+    });
+  }
+  readlink(path, options = {}) {
+    return this.operation("readlink", path, options, async () => {
+      const location = await this.resolve(path, options, { followFinal: false });
+      if (location.stat?.type !== "symlink") fail("EINVAL");
+      return this.optional(location, "readlink", "symlinks").call(location.mount.backend, location.local, options);
+    });
+  }
+  symlink(target, path, options = {}) {
+    return this.operation("symlink", path, options, async () => {
+      this.components(target);
+      const location = await this.resolve(path, options, { followFinal: false, allowMissing: true });
+      this.mutable(location);
+      await this.optional(location, "symlink", "symlinks").call(location.mount.backend, target, location.local, options);
+    });
+  }
+  link(existingPath, newPath, options = {}) {
+    return this.operation("link", existingPath, options, async () => {
+      const origin = await this.resolve(existingPath, options, { followFinal: false, entry: true });
+      const target = await this.resolve(newPath, options, { followFinal: false, allowMissing: true, entry: true });
+      if (this.protected(origin.path) || this.protected(target.path)) fail("EBUSY");
+      if (origin.mount !== target.mount) fail("EXDEV");
+      this.mutable(origin);
+      this.mutable(target);
+      await this.optional(origin, "link", "hardlinks").call(origin.mount.backend, origin.local, target.local, options);
+    }, newPath);
+  }
+  chmod(path, mode2, options = {}) {
+    return this.operation("chmod", path, options, async () => {
+      const location = await this.resolve(path, options);
+      this.mutable(location);
+      await this.optional(location, "chmod", "permissions").call(location.mount.backend, location.local, mode2, options);
+    });
+  }
+  utimes(path, atimeMs, mtimeMs, options = {}) {
+    return this.operation("utimes", path, options, async () => {
+      const location = await this.resolve(path, options);
+      this.mutable(location);
+      await this.optional(location, "utimes", "timestamps").call(location.mount.backend, location.local, atimeMs, mtimeMs, options);
+    });
+  }
+  truncate(path, length = 0, options = {}) {
+    return this.operation("truncate", path, options, async () => {
+      const location = await this.resolve(path, options);
+      this.mutable(location);
+      await this.optional(location, "truncate").call(location.mount.backend, location.local, length, options);
+    });
+  }
+  async *readStream(path, options = {}) {
+    try {
+      options.signal?.throwIfAborted();
+      const location = await this.resolve(path, options);
+      if (location.synthetic) fail("EISDIR");
+      const source = this.optional(location, "readStream", "streamingRead").call(location.mount.backend, location.local, options);
+      for await (const chunk of readBytes(source, options.signal)) {
+        options.signal?.throwIfAborted();
+        yield chunk;
+      }
+      options.signal?.throwIfAborted();
+    } catch (error) {
+      throw this.error(error, "readStream", path, options);
+    }
+  }
+  writeStream(path, source, options = {}) {
+    return this.operation("writeStream", path, options, async () => {
+      const location = await this.resolve(path, options, { allowMissing: true, followFinal: !options.flag?.endsWith("x") });
+      this.mutable(location);
+      await this.optional(location, "writeStream", "streamingWrite").call(location.mount.backend, location.local, source, options);
+    });
+  }
+};
+function createMountFileSystem(options) {
+  return new MountFileSystem(options);
+}
+
+// packages/safe-fs/src/fs/overlay/index.ts
+function snapshotStat3(stat) {
+  const { type, size, allocatedBytes, mode: mode2, mtimeMs, atimeMs, ctimeMs, birthtimeMs, identityScope, ino, dev, nlink, uid, gid } = stat;
+  return {
+    type,
+    size,
+    mode: mode2,
+    mtimeMs,
+    atimeMs,
+    ctimeMs,
+    ...allocatedBytes === void 0 ? {} : { allocatedBytes },
+    ...birthtimeMs === void 0 ? {} : { birthtimeMs },
+    ...identityScope === void 0 ? {} : { identityScope },
+    ...ino === void 0 ? {} : { ino },
+    ...dev === void 0 ? {} : { dev },
+    ...nlink === void 0 ? {} : { nlink },
+    ...uid === void 0 ? {} : { uid },
+    ...gid === void 0 ? {} : { gid }
+  };
+}
+function hasCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function fail2(code, path, message) {
+  throw new FsError(code, { syscall: "overlay", path, ...message === void 0 ? {} : { message } });
+}
+function integer(value, path) {
+  if (!Number.isSafeInteger(value) || value < 0) fail2("EINVAL", path);
+}
+function mode(value, path) {
+  if (value !== void 0 && (!Number.isInteger(value) || value < 0 || value > 4095)) fail2("EINVAL", path);
+}
+function movedPath(path, moves) {
+  for (const move of moves) {
+    if (isPathWithin(move.source, path)) path = move.destination + path.slice(move.source.length);
+  }
+  return path;
+}
+async function waitForTurn(previous, signal) {
+  signal?.throwIfAborted();
+  if (!signal) return previous;
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    void previous.then(() => {
+      signal.removeEventListener("abort", abort);
+      resolve();
+    });
+  });
+}
+var OverlayFileSystem = class {
+  capabilities;
+  #upper;
+  #lower;
+  maxBufferBytes;
+  whiteouts = /* @__PURE__ */ new Set();
+  opaque = /* @__PURE__ */ new Set();
+  garbage = /* @__PURE__ */ new Set();
+  activeStages = /* @__PURE__ */ new Set();
+  linkMetadata = /* @__PURE__ */ new Map();
+  linkOrigins = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  constructor(options) {
+    if (options.upper === options.lower) throw new TypeError("Overlay upper and lower must be distinct backends");
+    this.#upper = options.upper;
+    this.#lower = options.lower;
+    registerEntryView(this, (path, options2) => this.run(options2, async () => {
+      const entry = await this.required(path, options2);
+      return { filesystem: entry.backend, path: entry.path, readOnly: this.capabilities.readOnly === true };
+    }, false));
+    this.maxBufferBytes = options.maxBufferBytes ?? 64 * 1024 * 1024;
+    integer(this.maxBufferBytes, "/");
+    const writable = !this.#upper.capabilities.readOnly && this.#upper.capabilities.atomicRename === true;
+    const readable = [this.#upper, this.#lower].map((backend) => typeof backend.readStream === "function" ? backend.capabilities.streamingRead : false);
+    const streamingRead = readable.every((capability) => capability === true) ? true : readable.every((capability) => capability === false) ? false : void 0;
+    const streamingWrite = writable && this.#upper.capabilities.streamingWrite === true && this.#upper.capabilities.streamingRead === true && typeof this.#upper.writeStream === "function" && typeof this.#upper.readStream === "function" ? readable.every((capability) => capability === true) ? true : void 0 : false;
+    this.capabilities = Object.freeze({
+      readOnly: !writable,
+      atomicRename: false,
+      hardlinks: false,
+      symlinks: writable && this.#upper.capabilities.symlinks === true && typeof this.#upper.symlink === "function" && typeof this.#upper.readlink === "function" && (this.#lower.capabilities.symlinks !== true || typeof this.#lower.readlink === "function"),
+      permissions: writable && this.#upper.capabilities.permissions === true && typeof this.#upper.chmod === "function",
+      timestamps: writable && this.#upper.capabilities.timestamps === true && typeof this.#upper.utimes === "function",
+      ...streamingRead === void 0 ? {} : { streamingRead },
+      ...streamingWrite === void 0 ? {} : { streamingWrite }
+    });
+    Object.defineProperty(this, "capabilities", { writable: false, configurable: false });
+  }
+  async run(options, operation, cleanup = true) {
+    options.signal?.throwIfAborted();
+    const previous = this.queue;
+    let release;
+    this.queue = new Promise((resolve) => {
+      release = resolve;
+    });
+    try {
+      await waitForTurn(previous, options.signal);
+    } catch (error) {
+      void previous.then(release);
+      throw error;
+    }
+    try {
+      options.signal?.throwIfAborted();
+      if (cleanup) await this.cleanGarbage(false);
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  writable(path) {
+    if (this.#upper.capabilities.readOnly) fail2("EROFS", path);
+    if (this.#upper.capabilities.atomicRename !== true) fail2("ENOTSUP", path, "staged mutations require an atomic-rename-capable upper");
+  }
+  permission(entry, mask) {
+    if (entry.backend.capabilities.permissions && (entry.stat.mode >> 6 & mask) !== mask) fail2("EACCES", entry.path);
+  }
+  async maybeStat(backend, path, options) {
+    options.signal?.throwIfAborted();
+    let stat;
+    try {
+      stat = await backend.lstat(path, options);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      if (hasCode(error, "ENOENT")) return void 0;
+      throw error;
+    }
+    return snapshotStat3(stat);
+  }
+  hidden(path) {
+    return [...this.garbage, ...this.activeStages].some((root) => isPathWithin(root, path));
+  }
+  async lowerVisible(path, options) {
+    for (const root of this.whiteouts) if (isPathWithin(root, path)) return false;
+    for (const root of this.opaque) if (root !== path && isPathWithin(root, path)) return false;
+    const ancestors = path.split("/").filter(Boolean).slice(0, -1);
+    let parent = "";
+    for (const component of ancestors) {
+      parent += `/${component}`;
+      const stat = await this.maybeStat(this.#lower, parent, options);
+      if (!stat || stat.type !== "directory") return false;
+    }
+    return true;
+  }
+  async lookup(path, options) {
+    if (this.hidden(path)) return void 0;
+    const upper = await this.maybeStat(this.#upper, path, options);
+    if (upper) return { path, backend: this.#upper, stat: { ...upper, ...upper.type === "symlink" ? this.linkMetadata.get(path) : {} } };
+    if (!await this.lowerVisible(path, options)) return void 0;
+    const lower = await this.maybeStat(this.#lower, path, options);
+    return lower ? { path, backend: this.#lower, stat: lower } : void 0;
+  }
+  async resolve(path, options, followFinal = true, allowMissing = false, createMode) {
+    validatePath(path);
+    if (!path) fail2("ENOENT", path);
+    const pending = path.split("/").filter(Boolean);
+    if (path.endsWith("/")) pending.push(".");
+    const verifications = [];
+    const verified = async (location) => {
+      for (const verification of verifications) {
+        const canonical = await verification.backend.realpath(verification.path, options);
+        options.signal?.throwIfAborted();
+        validatePath(canonical);
+        if (!canonical.startsWith("/")) fail2("EIO", verification.path, "backend returned a nonabsolute realpath");
+        if (verification.finalName !== void 0) {
+          try {
+            await verification.backend.lstat(`${verification.path}/${verification.finalName}`, options);
+          } catch (error) {
+            if (location.entry || !hasCode(error, "ENOENT")) throw error;
+          }
+        }
+        const expected = verification.finalName === void 0 ? canonical : `${canonical === "/" ? "" : canonical}/${verification.finalName}`;
+        if (location.path !== movedPath(expected, verification.moves ?? [])) fail2("ENOTSUP", path, "backend cannot confirm the overlay symlink namespace");
+      }
+      options.signal?.throwIfAborted();
+      return location;
+    };
+    let current = "/";
+    let links = 0;
+    while (pending.length) {
+      options.signal?.throwIfAborted();
+      const parent = await this.lookup(current, options);
+      if (!parent) fail2("ENOENT", current);
+      if (parent.stat.type !== "directory") fail2("ENOTDIR", current);
+      this.permission(parent, 1);
+      const component = pending.shift();
+      if (component === ".") continue;
+      if (component === "..") {
+        current = dirname(current);
+        continue;
+      }
+      if (new TextEncoder().encode(component).byteLength > 255) fail2("ENAMETOOLONG", path);
+      const candidate = current === "/" ? `/${component}` : `${current}/${component}`;
+      if (this.hidden(candidate)) fail2(allowMissing || createMode !== void 0 ? "EBUSY" : "ENOENT", candidate);
+      let entry2 = await this.lookup(candidate, options);
+      if (!entry2 && createMode !== void 0) {
+        if (verifications.length) fail2("ENOTSUP", path, "recursive creation through symlinks cannot be verified before mutation");
+        await this.makeDirectory(candidate, createMode, options);
+        entry2 = await this.lookup(candidate, options);
+      }
+      if (!entry2) {
+        if (allowMissing && pending.length === 0) return verified({ path: candidate });
+        fail2("ENOENT", candidate);
+      }
+      if (entry2.stat.type === "symlink" && (followFinal || pending.length > 0)) {
+        if (++links > 40) fail2("ELOOP", path);
+        const suffix = [...pending];
+        const last = suffix.at(-1);
+        const finalName = !followFinal && last !== void 0 && last !== "." && last !== ".." ? suffix.pop() : void 0;
+        verifications.push({
+          backend: entry2.backend,
+          path: candidate + (suffix.length ? `/${suffix.join("/")}` : ""),
+          finalName
+        });
+        const origin = entry2.backend === this.#upper ? this.linkOrigins.get(candidate) : void 0;
+        if (origin) verifications.push({
+          backend: this.#lower,
+          path: origin.path + (suffix.length ? `/${suffix.join("/")}` : ""),
+          finalName,
+          moves: origin.moves
+        });
+        const target = await this.linkTarget(entry2, options);
+        const parts = target.split("/").filter(Boolean);
+        if (target.endsWith("/")) parts.push(".");
+        pending.unshift(...parts);
+        if (target.startsWith("/")) current = "/";
+      } else current = candidate;
+    }
+    const entry = await this.lookup(current, options);
+    if (!entry) fail2("ENOENT", current);
+    return verified({ path: current, entry });
+  }
+  async linkTarget(entry, options) {
+    if (!entry.backend.readlink) fail2("ENOTSUP", entry.path);
+    const target = await entry.backend.readlink(entry.path, options);
+    options.signal?.throwIfAborted();
+    validatePath(target);
+    if (!target) fail2("ENOENT", entry.path);
+    return target;
+  }
+  async movableLinkTarget(entry, options) {
+    const target = await this.linkTarget(entry, options);
+    const canonical = await entry.backend.realpath(entry.path, options);
+    options.signal?.throwIfAborted();
+    const parts = target.split("/").filter(Boolean);
+    if (target.endsWith("/")) parts.push(".");
+    let current = target.startsWith("/") ? "/" : dirname(entry.path);
+    let stat = await this.maybeStat(entry.backend, current, options);
+    for (const part of parts) {
+      if (!stat) fail2("ENOENT", current);
+      if (stat.type !== "directory") fail2("ENOTSUP", entry.path, "symlink copy-up requires an alias-free target path");
+      if (part === ".") continue;
+      current = part === ".." ? dirname(current) : `${current === "/" ? "" : current}/${part}`;
+      stat = await this.maybeStat(entry.backend, current, options);
+      if (stat?.type === "symlink") fail2("ENOTSUP", entry.path, "symlink copy-up cannot preserve an ambiguous target alias");
+    }
+    if (!stat) fail2("ENOENT", current);
+    if (canonical !== current) fail2("ENOTSUP", entry.path, "backend cannot prove symlink semantics survive copy-up");
+    return target;
+  }
+  async required(path, options, followFinal = true) {
+    return (await this.resolve(path, options, followFinal)).entry;
+  }
+  async listing(entry, options) {
+    if (entry.stat.type !== "directory") fail2("ENOTDIR", entry.path);
+    this.permission(entry, 4);
+    const names = /* @__PURE__ */ new Set();
+    const upper = await this.maybeStat(this.#upper, entry.path, options);
+    if (upper?.type === "directory") {
+      for (const child of await this.#upper.readdir(entry.path, options)) names.add(child.name);
+    }
+    if (await this.lowerVisible(entry.path, options) && !this.opaque.has(entry.path)) {
+      const lower = await this.maybeStat(this.#lower, entry.path, options);
+      if (lower?.type === "directory") {
+        for (const child of await this.#lower.readdir(entry.path, options)) names.add(child.name);
+      }
+    }
+    const entries2 = [];
+    for (const name of [...names].sort()) {
+      if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0")) fail2("EIO", entry.path, "invalid backend directory entry");
+      const child = await this.lookup(entry.path === "/" ? `/${name}` : `${entry.path}/${name}`, options);
+      if (child) entries2.push({ name, type: child.stat.type });
+    }
+    return entries2;
+  }
+  async bytes(entry, options) {
+    if (entry.stat.type !== "file") fail2("EISDIR", entry.path);
+    this.permission(entry, 4);
+    if (options.maxBytes !== void 0) integer(options.maxBytes, entry.path);
+    const limit = Math.min(options.maxBytes ?? this.maxBufferBytes, this.maxBufferBytes);
+    if (entry.stat.size > limit) fail2("EFBIG", entry.path);
+    const result = await entry.backend.readFile(entry.path, { ...options, maxBytes: limit });
+    options.signal?.throwIfAborted();
+    if (!(result instanceof Uint8Array)) fail2("EIO", entry.path, "backend returned non-byte data");
+    if (result.byteLength > limit) fail2("EFBIG", entry.path);
+    return new Uint8Array(result);
+  }
+  async cleanGarbage(strict) {
+    const failures = [];
+    for (const path of this.garbage) {
+      try {
+        await this.#upper.rm(path, { recursive: true, force: true });
+        this.garbage.delete(path);
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (strict && failures.length) throw new AggregateError(failures, "Overlay staging cleanup failed");
+  }
+  async cleanup(options = {}) {
+    return this.run(options, () => this.cleanGarbage(true));
+  }
+  async staged(options, operation) {
+    const root = `/.virtual-bash-overlay-${platform.randomUUID()}`;
+    if (await this.maybeStat(this.#upper, root, options) || await this.maybeStat(this.#lower, root, options)) fail2("EEXIST", root);
+    this.activeStages.add(root);
+    try {
+      await this.#upper.mkdir(root, { ...options, mode: 448 });
+      return await operation(`${root}/entry`);
+    } finally {
+      this.activeStages.delete(root);
+      this.garbage.add(root);
+      await this.cleanGarbage(false);
+    }
+  }
+  async preserve(path, stat, options) {
+    if (this.#upper.chmod) await this.#upper.chmod(path, stat.mode & 4095, options);
+    else if (((await this.#upper.lstat(path, options)).mode & 4095) !== (stat.mode & 4095)) fail2("ENOTSUP", path, "upper cannot preserve modes");
+    if (!this.#upper.utimes) fail2("ENOTSUP", path, "upper cannot preserve timestamps during copy-up");
+    await this.#upper.utimes(path, stat.atimeMs, stat.mtimeMs, options);
+  }
+  async clone(entry, destination, options, streaming = false) {
+    if (entry.stat.type !== "directory" && ((entry.stat.nlink ?? 1) > 1 || entry.backend.capabilities.hardlinks === true && entry.stat.nlink === void 0)) {
+      fail2("ENOTSUP", entry.path, "copy-up cannot preserve hardlink identity");
+    }
+    if (entry.stat.type === "symlink") {
+      if (!this.capabilities.symlinks || !entry.backend.readlink || !this.#upper.symlink) fail2("ENOTSUP", entry.path);
+      await this.#upper.symlink(await this.movableLinkTarget(entry, options), destination, options);
+      return;
+    }
+    if (entry.stat.type === "directory") await this.#upper.mkdir(destination, { ...options, mode: entry.stat.mode & 4095 });
+    else if (streaming && entry.backend.readStream && entry.backend.capabilities.streamingRead !== false && this.#upper.writeStream) {
+      this.permission(entry, 4);
+      if (entry.stat.size > this.maxBufferBytes) fail2("EFBIG", entry.path);
+      const source = this.bounded(entry.backend.readStream(entry.path, options), entry.path, options);
+      await this.streamToUpper(destination, source, { ...options, mode: 384, flag: "wx" });
+    } else await this.#upper.writeFile(destination, await this.bytes(entry, options), { ...options, mode: 384, flag: "wx" });
+    await this.preserve(destination, entry.stat, options);
+  }
+  rememberLink(entry, destination) {
+    this.linkMetadata.delete(destination);
+    if (entry.stat.type === "symlink") {
+      this.linkMetadata.set(destination, { mode: entry.stat.mode, atimeMs: entry.stat.atimeMs, mtimeMs: entry.stat.mtimeMs });
+    }
+  }
+  async ensureDirectory(path, options) {
+    const entry = await this.lookup(path, options);
+    if (!entry) fail2("ENOENT", path);
+    if (entry.stat.type !== "directory") fail2("ENOTDIR", path);
+    if (entry.backend === this.#upper) return;
+    await this.copyUp(entry, options);
+  }
+  async copyUp(entry, options) {
+    if (entry.backend === this.#upper) return;
+    if (entry.path === "/") fail2("ENOTSUP", entry.path, "upper must have a directory root");
+    let origin;
+    if (entry.stat.type === "symlink") {
+      const target = await this.movableLinkTarget(entry, options);
+      origin = { path: entry.path, target, canonical: normalizePath(target, dirname(entry.path)), moves: [] };
+    }
+    await this.ensureDirectory(dirname(entry.path), options);
+    await this.staged(options, async (temporary) => {
+      await this.clone(entry, temporary, options);
+      options.signal?.throwIfAborted();
+      await this.#upper.rename(temporary, entry.path, options);
+      this.rememberLink(entry, entry.path);
+      if (origin) this.linkOrigins.set(entry.path, origin);
+    });
+  }
+  async parent(path, options) {
+    const parent = await this.lookup(dirname(path), options);
+    if (!parent) fail2("ENOENT", dirname(path));
+    if (parent.stat.type !== "directory") fail2("ENOTDIR", dirname(path));
+    this.permission(parent, 3);
+    await this.ensureDirectory(parent.path, options);
+  }
+  async makeDirectory(path, permissions, options) {
+    await this.parent(path, options);
+    await this.staged(options, async (temporary) => {
+      await this.#upper.mkdir(temporary, { ...options, mode: permissions });
+      options.signal?.throwIfAborted();
+      await this.#upper.rename(temporary, path, options);
+      this.opaque.add(path);
+      this.linkMetadata.delete(path);
+      this.linkOrigins.delete(path);
+    });
+  }
+  writeOptions(path, options) {
+    this.writable(path);
+    mode(options.mode, path);
+    if (!["w", "wx", "a", "ax"].includes(options.flag ?? "w")) fail2("EINVAL", path);
+  }
+  async writeLocation(path, options) {
+    const exclusive = options.flag === "wx" || options.flag === "ax";
+    const location = await this.resolve(path, options, !exclusive, true);
+    if (exclusive && location.entry) fail2("EEXIST", path);
+    if (location.entry) {
+      if (location.entry.stat.type !== "file") fail2("EISDIR", path);
+      this.permission(location.entry, 2);
+    }
+    return location;
+  }
+  async replace(location, options, operation, streaming = false) {
+    await this.parent(location.path, options);
+    await this.staged(options, async (temporary) => {
+      if (location.entry) await this.clone(location.entry, temporary, options, streaming);
+      await operation(temporary);
+      options.signal?.throwIfAborted();
+      await this.#upper.rename(temporary, location.path, options);
+      this.linkMetadata.delete(location.path);
+      this.linkOrigins.delete(location.path);
+    });
+  }
+  async readFile(path, options = {}) {
+    return this.run(options, async () => this.bytes(await this.required(path, options), options));
+  }
+  async writeFile(path, data, options = {}) {
+    options.signal?.throwIfAborted();
+    this.writeOptions(path, options);
+    if (!(data instanceof Uint8Array)) throw new TypeError("Overlay files require Uint8Array data");
+    if (data.byteLength > this.maxBufferBytes) fail2("EFBIG", path);
+    const bytes = new Uint8Array(data);
+    return this.run(options, async () => {
+      const location = await this.writeLocation(path, options);
+      const append = options.flag === "a" || options.flag === "ax";
+      if (append && (location.entry?.stat.size ?? 0) + bytes.byteLength > this.maxBufferBytes) fail2("EFBIG", path);
+      await this.replace(location, options, async (temporary) => {
+        await this.#upper.writeFile(temporary, bytes, { ...options, flag: append ? "a" : "w" });
+      });
+    });
+  }
+  async appendFile(path, data, options = {}) {
+    return this.writeFile(path, data, { ...options, flag: "a" });
+  }
+  async stat(path, options = {}) {
+    return this.run(options, async () => snapshotStat3((await this.required(path, options)).stat), false);
+  }
+  async lstat(path, options = {}) {
+    return this.run(options, async () => snapshotStat3((await this.required(path, options, false)).stat), false);
+  }
+  compareEntry(path, peer, peerPath, options = {}) {
+    return compareEntries(this, path, peer, peerPath, options);
+  }
+  async readdir(path, options = {}) {
+    return this.run(options, async () => this.listing(await this.required(path, options), options), false);
+  }
+  async realpath(path, options = {}) {
+    return this.run(options, async () => (await this.required(path, options)).path, false);
+  }
+  async access(path, requestedMode = 0, options = {}) {
+    return this.run(options, async () => {
+      if (!Number.isInteger(requestedMode) || requestedMode < 0 || requestedMode > 7) fail2("EINVAL", path);
+      const entry = await this.required(path, options);
+      if (requestedMode & 2) this.writable(path);
+      this.permission(entry, requestedMode);
+      await entry.backend.access(entry.path, requestedMode & ~2, options);
+    }, false);
+  }
+  async mkdir(path, options = {}) {
+    return this.run(options, async () => {
+      this.writable(path);
+      mode(options.mode, path);
+      validatePath(path);
+      if (options.recursive) {
+        const entry = (await this.resolve(path, options, true, false, options.mode ?? 511)).entry;
+        if (entry.stat.type !== "directory") fail2("EEXIST", path);
+      } else {
+        const location = await this.resolve(path.replace(/\/+$/, "") || (path ? "/" : ""), options, false, true);
+        if (location.entry) fail2("EEXIST", path);
+        await this.makeDirectory(location.path, options.mode ?? 511, options);
+      }
+    });
+  }
+  async rmdir(path, options = {}) {
+    try {
+      await this.run(options, async () => {
+        this.writable(path);
+        validatePath(path);
+        const entry = await this.required(path.replace(/\/+$/, "") || (path ? "/" : ""), options, false);
+        if (/(?:^|\/)\.{1,2}\/*$/.test(path)) fail2("EINVAL", path);
+        if (entry.path === "/") fail2("EBUSY", path);
+        if (entry.stat.type !== "directory") fail2("ENOTDIR", path);
+        const parent = await this.required(dirname(entry.path), options);
+        this.permission(parent, 3);
+        if ((await this.listing(entry, options)).length) fail2("ENOTEMPTY", path);
+        options.signal?.throwIfAborted();
+        if (this.#upper.capabilities.snapshotRmdir === true) {
+          fail2("ENOTSUP", path, "snapshot-marker upper removal cannot safely publish an overlay whiteout");
+        }
+        if (entry.backend === this.#upper) {
+          if (!this.#upper.rmdir) fail2("ENOTSUP", path);
+          await this.#upper.rmdir(entry.path, options);
+        }
+        this.whiteouts.add(entry.path);
+        for (const key of this.linkMetadata.keys()) if (isPathWithin(entry.path, key)) this.linkMetadata.delete(key);
+        for (const key of this.linkOrigins.keys()) if (isPathWithin(entry.path, key)) this.linkOrigins.delete(key);
+      }, false);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      throw new FsError(toFsError(error).code, { syscall: "rmdir", path, cause: error });
+    }
+  }
+  async rm(path, options = {}) {
+    return this.run(options, async () => {
+      this.writable(path);
+      let entry;
+      try {
+        entry = await this.required(path, options, false);
+      } catch (error) {
+        if (options.force && hasCode(error, "ENOENT")) return;
+        throw error;
+      }
+      if (entry.path === "/") fail2("EBUSY", path);
+      if (entry.stat.type === "directory" && !options.recursive && (await this.listing(entry, options)).length) fail2("ENOTEMPTY", path);
+      await this.parent(entry.path, options);
+      if (entry.backend === this.#upper) {
+        await this.staged(options, async (temporary) => {
+          options.signal?.throwIfAborted();
+          await this.#upper.rename(entry.path, temporary, options);
+          this.whiteouts.add(entry.path);
+        });
+      } else {
+        options.signal?.throwIfAborted();
+        this.whiteouts.add(entry.path);
+      }
+      for (const key of this.linkMetadata.keys()) if (isPathWithin(entry.path, key)) this.linkMetadata.delete(key);
+      for (const key of this.linkOrigins.keys()) if (isPathWithin(entry.path, key)) this.linkOrigins.delete(key);
+    });
+  }
+  async materialize(entry, options) {
+    if (entry.stat.type === "symlink" && entry.backend === this.#upper) await this.movableLinkTarget(entry, options);
+    const children = entry.stat.type === "directory" ? await this.listing(entry, options) : [];
+    await this.copyUp(entry, options);
+    for (const child of children) {
+      const path = `${entry.path}/${child.name}`;
+      const visible = await this.lookup(path, options);
+      if (!visible) fail2("EIO", path, "visible tree changed during materialization");
+      await this.materialize(visible, options);
+    }
+    if (entry.stat.type === "directory") await this.preserve(entry.path, entry.stat, options);
+  }
+  async rename(source, destination, options = {}) {
+    return this.run(options, async () => {
+      this.writable(source);
+      const original = await this.required(source, options, false);
+      const target = await this.resolve(destination, options, false, true);
+      if (original.path === target.path) return;
+      if (original.path === "/" || target.path === "/") fail2("EBUSY", source);
+      if (original.stat.type === "directory" && isPathWithin(original.path, target.path)) fail2("EINVAL", destination);
+      if (target.entry) {
+        if (original.stat.type === "directory" && target.entry.stat.type !== "directory") fail2("ENOTDIR", destination);
+        if (original.stat.type !== "directory" && target.entry.stat.type === "directory") fail2("EISDIR", destination);
+        if (target.entry.stat.type === "directory" && (await this.listing(target.entry, options)).length) fail2("ENOTEMPTY", destination);
+      }
+      await this.parent(original.path, options);
+      await this.parent(target.path, options);
+      await this.materialize(original, options);
+      options.signal?.throwIfAborted();
+      const move = { source: original.path, destination: target.path };
+      const movedOrigins = [];
+      for (const [path, origin] of this.linkOrigins) {
+        if (!isPathWithin(original.path, path)) continue;
+        const destination2 = movedPath(path, [move]);
+        const moves = origin.target.startsWith("/") ? origin.moves : [...origin.moves, move];
+        if (normalizePath(origin.target, dirname(destination2)) !== movedPath(origin.canonical, moves)) {
+          fail2("ENOTSUP", path, "relocation changes an unprovable relative symlink target");
+        }
+        movedOrigins.push([destination2, { ...origin, moves }]);
+      }
+      options.signal?.throwIfAborted();
+      await this.#upper.rename(original.path, target.path, options);
+      this.whiteouts.add(original.path);
+      if (original.stat.type === "directory") this.opaque.add(target.path);
+      const moved = [...this.linkMetadata].filter(([path]) => isPathWithin(original.path, path));
+      for (const path of this.linkMetadata.keys()) {
+        if (isPathWithin(original.path, path) || isPathWithin(target.path, path)) this.linkMetadata.delete(path);
+      }
+      for (const [path, metadata] of moved) this.linkMetadata.set(target.path + path.slice(original.path.length), metadata);
+      for (const path of this.linkOrigins.keys()) {
+        if (isPathWithin(original.path, path) || isPathWithin(target.path, path)) this.linkOrigins.delete(path);
+      }
+      for (const [path, origin] of movedOrigins) this.linkOrigins.set(path, origin);
+    });
+  }
+  async copyFile(source, destination, options = {}) {
+    return this.run(options, async () => {
+      this.writable(destination);
+      const original = await this.required(source, options);
+      const target = await this.writeLocation(destination, { ...options, flag: options.exclusive ? "wx" : "w" });
+      if (original.path === target.path) fail2("EINVAL", destination, "source and destination are the same file");
+      if (target.entry) {
+        let identity = compareIdentity(original.stat, target.entry.stat);
+        if (identity === "unknown") identity = await compareEntries(original.backend, original.path, target.entry.backend, target.entry.path, options);
+        if (identity === "same") fail2("EINVAL", destination, "source and destination are the same file");
+        if (identity === "unknown") fail2("ENOTSUP", destination, "backing-entry identity is unknown");
+      }
+      if (target.entry?.backend !== this.#upper) {
+        const upper = await this.maybeStat(this.#upper, target.path, options);
+        if (upper) {
+          let identity = compareIdentity(original.stat, upper);
+          if (identity === "unknown") identity = await compareEntries(original.backend, original.path, this.#upper, target.path, options);
+          if (identity === "same") fail2("EINVAL", destination, "source and destination are the same file");
+          if (identity === "unknown") fail2("ENOTSUP", destination, "upper backing-entry identity is unknown");
+        }
+      }
+      await this.cleanGarbage(false);
+      const bytes = await this.bytes(original, options);
+      await this.replace(target, options, async (temporary) => {
+        await this.#upper.writeFile(temporary, bytes, { ...options, mode: original.stat.mode & 4095, flag: "w" });
+        if (this.#upper.chmod) await this.#upper.chmod(temporary, original.stat.mode & 4095, options);
+        else if (((await this.#upper.lstat(temporary, options)).mode & 4095) !== (original.stat.mode & 4095)) fail2("ENOTSUP", destination);
+      });
+    }, false);
+  }
+  async readlink(path, options = {}) {
+    return this.run(options, async () => {
+      const entry = await this.required(path, options, false);
+      if (entry.stat.type !== "symlink") fail2("EINVAL", path);
+      if (!entry.backend.readlink) fail2("ENOTSUP", path);
+      return entry.backend.readlink(entry.path, options);
+    }, false);
+  }
+  async symlink(target, path, options = {}) {
+    return this.run(options, async () => {
+      this.writable(path);
+      if (!this.capabilities.symlinks || !this.#upper.symlink) fail2("ENOTSUP", path);
+      validatePath(target);
+      if (!target) fail2("ENOENT", path);
+      const location = await this.resolve(path, options, false, true);
+      if (location.entry) fail2("EEXIST", path);
+      await this.replace(location, options, (temporary) => this.#upper.symlink(target, temporary, options));
+    });
+  }
+  async link(_existingPath, newPath, options = {}) {
+    options.signal?.throwIfAborted();
+    fail2("ENOTSUP", newPath, "overlay hardlinks are not supported");
+  }
+  async metadata(path, capability, options, operation) {
+    return this.run(options, async () => {
+      this.writable(path);
+      if (!this.capabilities[capability]) fail2("ENOTSUP", path);
+      const entry = await this.required(path, options);
+      if (entry.stat.type === "directory") {
+        await this.copyUp(entry, options);
+        await operation(entry.path);
+      } else await this.replace({ path: entry.path, entry }, options, operation);
+    });
+  }
+  async chmod(path, permissions, options = {}) {
+    options.signal?.throwIfAborted();
+    if (permissions === void 0) fail2("EINVAL", path);
+    mode(permissions, path);
+    return this.metadata(path, "permissions", options, (target) => this.#upper.chmod(target, permissions, options));
+  }
+  async utimes(path, atimeMs, mtimeMs, options = {}) {
+    options.signal?.throwIfAborted();
+    if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs)) fail2("EINVAL", path);
+    return this.metadata(path, "timestamps", options, (target) => this.#upper.utimes(target, atimeMs, mtimeMs, options));
+  }
+  async truncate(path, length = 0, options = {}) {
+    integer(length, path);
+    return this.run(options, async () => {
+      this.writable(path);
+      if (length > this.maxBufferBytes) fail2("EFBIG", path);
+      const entry = await this.required(path, options);
+      if (entry.stat.type !== "file") fail2("EISDIR", path);
+      this.permission(entry, 2);
+      await this.replace({ path: entry.path, entry }, options, async (temporary) => {
+        if (this.#upper.truncate) await this.#upper.truncate(temporary, length, options);
+        else {
+          const previous = await this.#upper.readFile(temporary, { ...options, maxBytes: this.maxBufferBytes });
+          const bytes = new Uint8Array(length);
+          bytes.set(previous.subarray(0, length));
+          await this.#upper.writeFile(temporary, bytes, options);
+        }
+      });
+    });
+  }
+  async *readStream(path, options = {}) {
+    options.signal?.throwIfAborted();
+    const start = options.start ?? 0;
+    const chunkSize = options.chunkSize ?? 64 * 1024;
+    integer(start, path);
+    integer(chunkSize, path);
+    if (!chunkSize) fail2("EINVAL", path);
+    if (options.endExclusive !== void 0) {
+      integer(options.endExclusive, path);
+      if (options.endExclusive < start) fail2("EINVAL", path);
+    }
+    const entry = await this.run(options, async () => {
+      const entry2 = await this.required(path, options);
+      if (entry2.stat.type !== "file") fail2("EISDIR", path);
+      this.permission(entry2, 4);
+      return entry2;
+    });
+    if (entry.backend.readStream && entry.backend.capabilities.streamingRead !== false) {
+      for await (const chunk of readBytes(entry.backend.readStream(entry.path, options), options.signal)) {
+        yield new Uint8Array(chunk);
+      }
+      options.signal?.throwIfAborted();
+      return;
+    }
+    const bytes = await this.bytes(entry, options);
+    const end = Math.min(bytes.byteLength, options.endExclusive ?? bytes.byteLength);
+    for (let offset = start; offset < end; offset += chunkSize) {
+      options.signal?.throwIfAborted();
+      yield bytes.slice(offset, Math.min(end, offset + chunkSize));
+    }
+    options.signal?.throwIfAborted();
+  }
+  async *bounded(source, path, options) {
+    let size = 0;
+    for await (const chunk of readBytes(source, options.signal)) {
+      if (chunk.byteLength > this.maxBufferBytes - size) fail2("EFBIG", path);
+      size += chunk.byteLength;
+      yield new Uint8Array(chunk);
+    }
+  }
+  async streamToUpper(path, source, options) {
+    if (!this.#upper.writeStream) fail2("ENOTSUP", path);
+    const input = readBytes(source, options.signal);
+    let failed = false;
+    try {
+      await this.#upper.writeStream(path, input, options);
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      await finishCleanup(() => input.return(void 0), failed);
+    }
+  }
+  async writeStream(path, source, options = {}) {
+    options.signal?.throwIfAborted();
+    this.writeOptions(path, options);
+    await this.run(options, () => this.writeLocation(path, options));
+    if (this.capabilities.streamingWrite !== false) {
+      await this.staged(options, async (incoming) => {
+        const bounded = this.bounded(source, path, options);
+        await this.streamToUpper(incoming, bounded, { ...options, flag: "wx", mode: 384 });
+        const size = (await this.#upper.stat(incoming, options)).size;
+        await this.run(options, async () => {
+          const location = await this.writeLocation(path, options);
+          const append = options.flag === "a" || options.flag === "ax";
+          if (append && (location.entry?.stat.size ?? 0) + size > this.maxBufferBytes) fail2("EFBIG", path);
+          await this.replace(location, options, async (temporary) => {
+            await this.streamToUpper(temporary, this.#upper.readStream(incoming, options), { ...options, flag: append ? "a" : "w" });
+          }, true);
+        });
+      });
+      return;
+    }
+    const bytes = await collectBytes(source, { maxBytes: this.maxBufferBytes, ...options.signal ? { signal: options.signal } : {} });
+    await this.writeFile(path, bytes, options);
+  }
+};
+function createOverlayFileSystem(options) {
+  return new OverlayFileSystem(options);
+}
+
+// packages/safe-fs/src/contracts/abort.ts
+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 };
+}
+
+// packages/safe-fs/src/fs/webdav/xml.ts
+var xmlNamespace = "http://www.w3.org/XML/1998/namespace";
+var xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
+function invalid(message) {
+  throw new SyntaxError(`Invalid WebDAV 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) {
+  const parts = name.split(":");
+  if (parts.length > 2 || parts.some((part) => {
+    const points = [...part].map((character) => character.codePointAt(0));
+    return points.length === 0 || !nameStart(points[0]) || points.slice(1).some((point) => !namePart(point));
+  })) invalid("invalid qualified name");
+  return parts.length === 1 ? ["", parts[0]] : [parts[0], parts[1]];
+}
+function entities(text) {
+  let result = "";
+  let offset = 0;
+  while (offset < text.length) {
+    const start = text.indexOf("&", offset);
+    if (start < 0) return result + text.slice(offset);
+    result += text.slice(offset, start);
+    const end = text.indexOf(";", 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("#") || !(hexadecimal ? /^[0-9a-fA-F]+$/ : /^[0-9]+$/).test(digits)) {
+        invalid("undeclared entity");
+      }
+      const point = Number.parseInt(digits, hexadecimal ? 16 : 10);
+      if (!validCharacter(point)) invalid("invalid character reference");
+      result += String.fromCodePoint(point);
+    }
+    offset = end + 1;
+  }
+  return result;
+}
+function parseXml(input, limits = {}) {
+  const maxDepth = limits.maxDepth ?? 64;
+  const maxNodes = limits.maxNodes ?? 1e5;
+  const maxAttributes = limits.maxAttributes ?? 1e4;
+  for (const limit of [maxDepth, maxNodes, maxAttributes]) {
+    if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("XML limits must be positive integers");
+  }
+  for (const character of input) {
+    if (!validCharacter(character.codePointAt(0))) invalid("invalid character");
+  }
+  const source = input.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+  const stack = [];
+  let root;
+  let offset = 0;
+  let nodes = 0;
+  let attributeCount = 0;
+  const whitespace = () => {
+    while (offset < source.length && " 	\n\r".includes(source[offset])) offset++;
+  };
+  const readName = () => {
+    const start = offset;
+    while (offset < source.length && !" 	\r\n/=>?".includes(source[offset])) offset++;
+    const name = source.slice(start, offset);
+    qualifiedName(name);
+    return name;
+  };
+  const appendText = (text) => {
+    const parent = stack.at(-1);
+    if (parent) parent.element.text += text;
+    else if (!/^[ \t\r\n]*$/.test(text)) invalid("text outside the root");
+  };
+  while (offset < source.length) {
+    if (source[offset] !== "<") {
+      const next = source.indexOf("<", offset);
+      const text = source.slice(offset, next < 0 ? source.length : next);
+      if (text.includes("]]>")) invalid("CDATA terminator in text");
+      appendText(entities(text));
+      offset += text.length;
+    } else if (source.startsWith("<!--", offset)) {
+      const end = source.indexOf("-->", offset + 4);
+      if (end < 0 || source.slice(offset + 4, end).includes("--") || source.slice(offset + 4, end).endsWith("-")) {
+        invalid("malformed comment");
+      }
+      offset = end + 3;
+    } else if (source.startsWith("<![CDATA[", offset)) {
+      if (!stack.length) invalid("CDATA outside root");
+      const end = source.indexOf("]]>", offset + 9);
+      if (end < 0) invalid("unterminated CDATA");
+      appendText(source.slice(offset + 9, end));
+      offset = end + 3;
+    } else if (source.startsWith("<?", offset)) {
+      const start = offset;
+      offset += 2;
+      const target = readName();
+      const end = source.indexOf("?>", offset);
+      if (end < 0) invalid("unterminated processing instruction");
+      const content = source.slice(offset, end);
+      if (target.toLowerCase() === "xml") {
+        if (start !== 0 || target !== "xml" || !/^\s+version\s*=\s*(['"])1\.0\1(?:\s+encoding\s*=\s*(['"])(?:UTF-8|UTF-16|UTF-16LE|UTF-16BE)\2)?(?:\s+standalone\s*=\s*(['"])(?:yes|no)\3)?\s*$/i.test(content)) {
+          invalid("unsupported XML declaration");
+        }
+      } else if (content && !" 	\n\r".includes(content[0])) invalid("invalid processing instruction");
+      offset = end + 2;
+    } else if (source.startsWith("<!", offset)) {
+      invalid("DTD and entity declarations are forbidden");
+    } else if (source.startsWith("</", offset)) {
+      offset += 2;
+      const name = readName();
+      whitespace();
+      if (source[offset++] !== ">" || stack.pop()?.name !== name) invalid("mismatched closing tag");
+    } else {
+      offset++;
+      const name = readName();
+      const attributes = /* @__PURE__ */ new Map();
+      const namespaces = new Map(stack.at(-1)?.namespaces ?? [["xml", xmlNamespace]]);
+      while (true) {
+        const beforeSpace = offset;
+        whitespace();
+        if (source[offset] === "/" || source[offset] === ">") break;
+        if (offset === beforeSpace) invalid("attributes require whitespace");
+        const attribute = readName();
+        if (attributes.has(attribute)) invalid("duplicate attribute");
+        if (++attributeCount > maxAttributes || attributes.size >= 128) invalid("XML attribute limit exceeded");
+        whitespace();
+        if (source[offset++] !== "=") invalid("missing attribute equals");
+        whitespace();
+        const quote = source[offset++];
+        if (quote !== '"' && quote !== "'") invalid("unquoted attribute");
+        const end = source.indexOf(quote, offset);
+        if (end < 0) invalid("unterminated attribute");
+        const raw = source.slice(offset, end);
+        if (raw.includes("<")) invalid("less-than in attribute");
+        const value = entities(raw.replace(/[\t\n\r]/g, " "));
+        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");
+          namespaces.set(prefix2, value);
+          if (namespaces.size > 256) invalid("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] = 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] = qualifiedName(name);
+      if (prefix === "xmlns" || prefix && !namespaces.has(prefix)) invalid("unbound element prefix");
+      const element = { namespace: namespaces.get(prefix) ?? "", localName, children: [], text: "" };
+      if (++nodes > maxNodes || stack.length + 1 > maxDepth) invalid("XML resource limit exceeded");
+      const parent = stack.at(-1);
+      if (parent) parent.element.children.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, name, namespaces });
+    }
+  }
+  if (stack.length || !root) invalid("incomplete document");
+  return root;
+}
+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) invalid(`duplicate DAV:${localName}`);
+  return children[0];
+}
+function scalar(element) {
+  if (element.children.length) invalid("expected text-only element");
+  return element.text.trim();
+}
+
+// packages/safe-fs/src/fs/webdav/webdav.ts
+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 validateDirectoryAccessPath(path) {
+  if (typeof path !== "string") fail3("EINVAL", "resolve", String(path), "invalid WebDAV path");
+  let bytes = 0;
+  let components = 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) {
+      components++;
+      inComponent = true;
+    }
+    bytes += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+    if (point > 65535) offset++;
+    if (bytes > 65536 || components > 256) {
+      fail3("ENAMETOOLONG", "access", 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({
+    symlinks: false,
+    hardlinks: false,
+    permissions: false,
+    timestamps: true,
+    atomicRename: false,
+    streamingRead: true,
+    streamingWrite: true
+  });
+  base;
+  baseSegments;
+  transport;
+  requestStreamSupport;
+  headers;
+  maxResponseBytes;
+  maxXmlBytes;
+  maxEntries;
+  timeoutMs;
+  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.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 deadline = createRequestTimeout(this.timeoutMs);
+    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 {
+      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) {
+    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 parseXml(new TextDecoder(encoding, { fatal: true }).decode(data), {
+      maxNodes: this.maxXmlBytes,
+      maxAttributes: this.maxXmlBytes
+    });
+  }
+  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");
+    }
+    const root = await this.xml(response, signal);
+    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") {
+    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();
+      for (const element of await this.multistatus(response, signal)) {
+        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");
+        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 stat(path, options = {}) {
+    const normalized = normalize(path);
+    const collection = requiresCollection(path);
+    try {
+      const stat = (await this.entries(normalized, "0", options, 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", options)).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 = {}) {
+    const normalized = normalize(path);
+    const entries2 = await this.entries(normalized, "1", options);
+    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 chunkSize = 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 += chunkSize) {
+          signal.throwIfAborted();
+          yield chunk.slice(offset, Math.min(last, offset + chunkSize));
+        }
+        position += chunk.byteLength;
+        if (position >= end) return;
+      }
+    }.bind(this));
+  }
+  async prepareWrite(path, options) {
+    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);
+    if (requiresCollection(path)) {
+      await this.stat(path, options);
+      fail3("EISDIR", "writeFile", path);
+    }
+    let parent = "";
+    for (const segment of normalized.slice(1).split("/").slice(0, -1)) {
+      parent += `/${segment}`;
+      await this.stat(`${parent}/`, options);
+    }
+    const exclusive = options.flag === "wx" || options.flag === "ax";
+    const existing = exclusive ? void 0 : await this.maybeStat(normalized, options);
+    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, options, { 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 readBytes(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 = {}) {
+    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) validateDirectoryAccessPath(path);
+    const stat = await this.stat(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-fs/src/bridge/stats.ts
+function predicates(type) {
+  return {
+    isFile: () => type === "file",
+    isDirectory: () => type === "directory",
+    isSymbolicLink: () => type === "symlink",
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+function bridgeStats(stat) {
+  return {
+    dev: stat.dev ?? 0,
+    ino: stat.ino ?? 0,
+    mode: stat.mode & 4095 | (stat.type === "directory" ? 16384 : stat.type === "symlink" ? 40960 : 32768),
+    nlink: stat.nlink ?? 1,
+    uid: stat.uid ?? 0,
+    gid: stat.gid ?? 0,
+    rdev: 0,
+    size: stat.size,
+    blksize: 4096,
+    blocks: Math.ceil(stat.size / 512),
+    atimeMs: stat.atimeMs,
+    mtimeMs: stat.mtimeMs,
+    ctimeMs: stat.ctimeMs,
+    birthtimeMs: stat.birthtimeMs ?? stat.ctimeMs,
+    atime: new Date(stat.atimeMs),
+    mtime: new Date(stat.mtimeMs),
+    ctime: new Date(stat.ctimeMs),
+    birthtime: new Date(stat.birthtimeMs ?? stat.ctimeMs),
+    ...predicates(stat.type)
+  };
+}
+function bridgeDirent(name, parentPath, type) {
+  return { name, parentPath, path: parentPath, ...predicates(type) };
+}
+
+// packages/safe-fs/src/bridge/values.ts
+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 booleanValue(value, fallback = false) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") throw new TypeError("Expected a boolean option");
+  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-fs/src/bridge/confinement.ts
+function denied(path) {
+  throw new FsError("EACCES", { syscall: "resolve", path, message: "path escapes the bridge cwd" });
+}
+function relativeComponents(root, path) {
+  if (typeof path !== "string" || !path.startsWith("/") || path.includes("\0")) denied(path);
+  const boundary = root.split("/").filter(Boolean);
+  const components = path.split("/").filter(Boolean);
+  let index = 0;
+  for (const component of boundary) {
+    while (components[index] === ".") index++;
+    if (components[index] !== component) denied(path);
+    index++;
+  }
+  const relative = components.slice(index);
+  let depth = 0;
+  for (const component of relative) {
+    if (component === ".") continue;
+    if (component === "..") {
+      if (depth === 0) denied(path);
+      depth--;
+    } else depth++;
+  }
+  if (path.endsWith("/")) relative.push(".");
+  return relative;
+}
+function assertBridgePath(root, path) {
+  if (root !== "/") relativeComponents(root, path);
+}
+async function assertCanonicalPath(fs, root, path, options) {
+  checkSignal(options.signal);
+  const canonical = await fs.realpath(path, options);
+  checkSignal(options.signal);
+  assertBridgePath(root, canonical);
+  if (canonical !== path) denied(path);
+}
+async function assertCanonicalOperand(fs, root, path, expected, options) {
+  let operand = path;
+  let target = expected;
+  while (true) {
+    checkSignal(options.signal);
+    try {
+      const canonical = await fs.realpath(operand, options);
+      checkSignal(options.signal);
+      assertBridgePath(root, canonical);
+      if (canonical !== target) denied(path);
+      return;
+    } catch (error) {
+      checkSignal(options.signal);
+      if (!isFsError(error) || error.code !== "ENOENT") throw error;
+      let missing = false;
+      try {
+        await fs.lstat(operand, options);
+      } catch (inspectionError) {
+        checkSignal(options.signal);
+        if (!isFsError(inspectionError) || inspectionError.code !== "ENOENT") throw inspectionError;
+        missing = true;
+      }
+      checkSignal(options.signal);
+      if (!missing || operand === root) denied(path);
+      operand = dirname(operand);
+      target = dirname(target);
+      assertBridgePath(root, operand);
+      assertBridgePath(root, target);
+    }
+  }
+}
+async function checkedBridgePath(fs, root, path, options, followFinal) {
+  if (root === "/") return path;
+  let pending = relativeComponents(root, path);
+  let current = "";
+  for (const component of root.split("/").filter(Boolean)) {
+    current += `/${component}`;
+    checkSignal(options.signal);
+    try {
+      const stat = await fs.lstat(current, options);
+      checkSignal(options.signal);
+      if (stat.type === "symlink") denied(current);
+      if (stat.type !== "directory")
+        throw new FsError("ENOTDIR", { syscall: "resolve", path: current });
+    } catch (error) {
+      checkSignal(options.signal);
+      if (!isFsError(error) || error.code !== "ENOENT") throw error;
+      if (current !== root) denied(path);
+      if (pending.includes("..")) throw error;
+      const parent = dirname(root);
+      await assertCanonicalPath(fs, parent, parent, options);
+      return path;
+    }
+  }
+  await assertCanonicalPath(fs, root, root, options);
+  let links = 0;
+  let finalLink = false;
+  let index = 0;
+  while (index < pending.length) {
+    const component = pending[index++];
+    checkSignal(options.signal);
+    if (component === ".") continue;
+    if (component === "..") {
+      if (current === root) denied(path);
+      current = dirname(current);
+      continue;
+    }
+    const candidate = `${current}/${component}`;
+    let stat;
+    try {
+      stat = await fs.lstat(candidate, options);
+    } catch (error) {
+      checkSignal(options.signal);
+      if (!isFsError(error) || error.code !== "ENOENT") throw error;
+      if (pending.slice(index).includes("..")) throw error;
+      await assertCanonicalPath(fs, root, current, options);
+      const expected = [candidate, ...pending.slice(index)].join("/");
+      await assertCanonicalOperand(fs, root, path, expected, options);
+      return path;
+    }
+    checkSignal(options.signal);
+    if (stat.type === "symlink" && (followFinal || index < pending.length)) {
+      if (++links > 40) throw new FsError("ELOOP", { syscall: "resolve", path });
+      if (typeof fs.readlink !== "function")
+        throw new FsError("ENOTSUP", { syscall: "readlink", path: candidate });
+      const target = await fs.readlink(candidate, options);
+      checkSignal(options.signal);
+      if (typeof target !== "string" || target.length === 0 || target.includes("\0"))
+        denied(candidate);
+      const absolute = target.startsWith("/") ? target : `${current}/${target}`;
+      pending = [...relativeComponents(root, absolute), ...pending.slice(index)];
+      index = 0;
+      current = root;
+      continue;
+    }
+    if (index < pending.length && stat.type !== "directory") {
+      throw new FsError("ENOTDIR", { syscall: "resolve", path: candidate });
+    }
+    current = candidate;
+    finalLink = stat.type === "symlink";
+  }
+  await assertCanonicalPath(fs, root, finalLink ? dirname(current) : current, options);
+  await assertCanonicalOperand(
+    fs,
+    root,
+    finalLink ? dirname(path) : path,
+    finalLink ? dirname(current) : current,
+    options
+  );
+  return path;
+}
+
+// packages/safe-fs/src/bridge/filesystem.ts
+function fsError(code, syscall, path) {
+  return Object.assign(new Error(`${code}: ${syscall}${path === void 0 ? "" : ` '${path}'`}`), {
+    code,
+    syscall,
+    ...path === void 0 ? {} : { path }
+  });
+}
+function unsupported(operation) {
+  throw fsError("ENOTSUP", operation);
+}
+function hasCode2(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+function childPath(parent, name) {
+  return `${parent.replace(/\/$/u, "")}/${name}`;
+}
+function optionsRecord(value, allowed) {
+  const options = value == null ? {} : typeof value === "string" ? { encoding: value } : record(value, "options");
+  onlyKeys(options, allowed);
+  return options;
+}
+function modeValue(value, fallback) {
+  if (value === void 0) return fallback;
+  const parsed = typeof value === "string" && /^[0-7]+$/u.test(value) ? Number.parseInt(value, 8) : value;
+  if (typeof parsed !== "number" || !Number.isInteger(parsed) || parsed < 0 || parsed > 4095) {
+    throw new TypeError("Invalid file mode");
+  }
+  return parsed;
+}
+function timeValue(value) {
+  const number = value instanceof Date ? value.getTime() : Number(value) * 1e3;
+  if (typeof value !== "string" && typeof value !== "number" && !(value instanceof Date) || !Number.isFinite(number)) {
+    throw new TypeError("Invalid timestamp");
+  }
+  return number;
+}
+var FileSystemBridge = class {
+  #fs;
+  #cwd;
+  #signal;
+  #primitives;
+  #codec;
+  constructor(fs, options, primitives) {
+    if (fs === void 0) throw new TypeError("An explicit filesystem is required");
+    const cwd = options.cwd ?? "/";
+    if (!primitives.paths.isAbsolute(cwd) || cwd.includes("\0")) throw new TypeError("cwd must be an absolute virtual path");
+    const codec = primitives.codec;
+    if (codec === void 0 || codec === null || typeof codec.isEncoding !== "function" || typeof codec.encode !== "function" || typeof codec.decode !== "function") {
+      throw new TypeError("An explicit filesystem codec is required");
+    }
+    this.#primitives = primitives;
+    this.#codec = Object.freeze({
+      isEncoding: codec.isEncoding.bind(codec),
+      encode: codec.encode.bind(codec),
+      decode: codec.decode.bind(codec)
+    });
+    this.#fs = fs;
+    this.#cwd = primitives.paths.resolve("/", cwd);
+    this.#signal = options.signal;
+  }
+  #encoding(value, fallback, names = false) {
+    const selected = value == null ? fallback : value;
+    if (typeof selected !== "string" || selected !== "buffer" && !this.#codec.isEncoding(selected) || names && !this.#codec.isEncoding("utf8")) {
+      throw new TypeError("Invalid encoding");
+    }
+    return selected;
+  }
+  #textBytes(value) {
+    return this.#primitives.copyBytes(this.#codec.encode(value, "utf8"));
+  }
+  #path(value) {
+    const path = this.#primitives.pathValue === void 0 ? value : this.#primitives.pathValue(value);
+    if (typeof path !== "string" || path.includes("\0")) throw new TypeError("Expected a path without NUL bytes; file handles are unsupported");
+    if (path.length === 0) throw fsError("ENOENT", "path", path);
+    checkSignal(this.#signal);
+    const absolute = this.#primitives.paths.isAbsolute(path) ? path : childPath(this.#cwd, path);
+    assertBridgePath(this.#cwd, absolute);
+    return absolute;
+  }
+  async #call(paths, operation, signal, noFollow = []) {
+    if (signal !== void 0 && !(signal instanceof AbortSignal)) throw new TypeError("Invalid AbortSignal");
+    const signalScope = signal !== void 0 && this.#signal !== void 0 && signal !== this.#signal ? composeAbortSignals([signal, this.#signal]) : void 0;
+    const combined = signalScope?.signal ?? signal ?? this.#signal;
+    try {
+      checkSignal(combined);
+      const options = combined === void 0 ? {} : { signal: combined };
+      return await withSignal(combined, async () => {
+        const absolute = paths.map((path) => this.#path(path));
+        const resolved = [...absolute];
+        if (this.#cwd !== "/") {
+          for (let index = 0; index < absolute.length; index++) {
+            resolved[index] = await checkedBridgePath(this.#fs, this.#cwd, absolute[index], options, !noFollow.includes(index));
+          }
+        }
+        checkSignal(combined);
+        return operation(options, resolved);
+      });
+    } finally {
+      signalScope?.dispose();
+    }
+  }
+  async readFile(path, value) {
+    const options = optionsRecord(value, ["encoding", "flag", "signal"]);
+    if (options.flag !== void 0 && options.flag !== "r") unsupported("readFile flag");
+    if (options.encoding === "buffer") throw new TypeError("Invalid read encoding");
+    const codec = this.#encoding(options.encoding, "buffer");
+    const bytes = await this.#call([path], (signal, resolved) => this.#fs.readFile(resolved[0], signal), options.signal);
+    const buffer = this.#primitives.copyBytes(bytes);
+    return codec === "buffer" ? buffer : this.#codec.decode(buffer, codec);
+  }
+  async #write(path, data, value, fallback) {
+    const options = optionsRecord(value, ["encoding", "flag", "mode", "flush", "signal"]);
+    if (booleanValue(options.flush)) unsupported("writeFile flush");
+    const codec = this.#encoding(options.encoding, "utf8");
+    if (codec === "buffer") throw new TypeError("Invalid write encoding");
+    const flag = options.flag ?? fallback;
+    if (flag !== "w" && flag !== "wx" && flag !== "a" && flag !== "ax") unsupported("writeFile flag");
+    const mode2 = modeValue(options.mode, 438);
+    let bytes;
+    if (typeof data === "string") bytes = this.#primitives.copyBytes(this.#codec.encode(data, codec));
+    else if (ArrayBuffer.isView(data)) bytes = this.#primitives.copyBytes(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    else throw new TypeError("writeFile accepts a string or ArrayBuffer view; streams and file handles are unsupported");
+    await this.#call([path], (signal, resolved) => this.#fs.writeFile(resolved[0], bytes, { ...signal, flag, mode: mode2 }), options.signal);
+  }
+  async writeFile(path, data, options) {
+    await this.#write(path, data, options, "w");
+  }
+  async appendFile(path, data, options) {
+    await this.#write(path, data, options, "a");
+  }
+  async stat(path, value) {
+    const options = optionsRecord(value, ["bigint"]);
+    if (booleanValue(options.bigint)) unsupported("stat bigint");
+    return bridgeStats(await this.#call([path], (signal, resolved) => this.#fs.stat(resolved[0], signal)));
+  }
+  async lstat(path, value) {
+    const options = optionsRecord(value, ["bigint"]);
+    if (booleanValue(options.bigint)) unsupported("lstat bigint");
+    return bridgeStats(await this.#call([path], (signal, resolved) => this.#fs.lstat(resolved[0], signal), void 0, [0]));
+  }
+  async readdir(path, value) {
+    const options = optionsRecord(value, ["encoding", "withFileTypes", "recursive"]);
+    const codec = this.#encoding(options.encoding, "utf8", true);
+    const withFileTypes = booleanValue(options.withFileTypes);
+    const recursive = booleanValue(options.recursive);
+    const root = this.#path(path);
+    const entries2 = [];
+    const pending = [root];
+    while (pending.length > 0) {
+      const directory = pending.shift();
+      if (directory === void 0) break;
+      for (const entry of await this.#call([directory], (signal, resolved) => this.#fs.readdir(resolved[0], signal))) {
+        if (entry.name === "" || entry.name === "." || entry.name === ".." || entry.name.includes("/") || entry.name.includes("\0")) {
+          throw new TypeError("Invalid directory entry from filesystem");
+        }
+        const fullPath = childPath(directory, entry.name);
+        entries2.push({ ...entry, parentPath: directory, relative: this.#primitives.paths.relative(root, fullPath) });
+        if (recursive && entry.type === "directory") pending.push(fullPath);
+      }
+    }
+    if (withFileTypes) {
+      return codec === "buffer" ? entries2.map((entry) => bridgeDirent(this.#textBytes(entry.name), entry.parentPath, entry.type)) : entries2.map((entry) => bridgeDirent(this.#codec.decode(this.#textBytes(entry.name), codec), entry.parentPath, entry.type));
+    }
+    return codec === "buffer" ? entries2.map((entry) => this.#textBytes(entry.relative)) : entries2.map((entry) => this.#codec.decode(this.#textBytes(entry.relative), codec));
+  }
+  async mkdir(path, value) {
+    const options = typeof value === "number" || typeof value === "string" ? { mode: value } : optionsRecord(value, ["mode", "recursive"]);
+    const mode2 = modeValue(options.mode, 511);
+    const recursive = booleanValue(options.recursive);
+    const target = this.#path(path);
+    let firstCreated;
+    if (recursive) {
+      let candidate = target;
+      while (true) {
+        try {
+          await this.#call([candidate], (signal, resolved) => this.#fs.stat(resolved[0], signal));
+          break;
+        } catch (error) {
+          if (!hasCode2(error, "ENOENT")) throw error;
+          firstCreated = candidate;
+          if (candidate === this.#cwd) break;
+          const parent = this.#primitives.paths.dirname(candidate);
+          if (parent === candidate) break;
+          candidate = parent;
+        }
+      }
+    }
+    await this.#call([target], (signal, resolved) => this.#fs.mkdir(resolved[0], { ...signal, mode: mode2, recursive }));
+    return firstCreated;
+  }
+  async access(path, mode2 = 0) {
+    if (!Number.isInteger(mode2) || mode2 < 0 || mode2 > 7) throw new TypeError("Invalid access mode");
+    await this.#call([path], (signal, resolved) => this.#fs.access(resolved[0], mode2, signal));
+  }
+  async rm(path, value) {
+    const options = optionsRecord(value, ["force", "recursive", "maxRetries", "retryDelay"]);
+    if (options.maxRetries !== void 0 && options.maxRetries !== 0) unsupported("rm retries");
+    if (options.retryDelay !== void 0) unsupported("rm retryDelay");
+    const recursive = booleanValue(options.recursive);
+    const force = booleanValue(options.force);
+    await this.#call([path], (signal, resolved) => this.#fs.rm(resolved[0], { ...signal, recursive, force }), void 0, [0]);
+  }
+  async rmdir(path, value) {
+    const options = optionsRecord(value, ["recursive", "maxRetries", "retryDelay"]);
+    const stat = await this.lstat(path);
+    if (!stat.isDirectory()) throw fsError("ENOTDIR", "rmdir", this.#path(path));
+    if (!booleanValue(options.recursive)) {
+      if ((await this.readdir(path)).length > 0) throw fsError("ENOTEMPTY", "rmdir", this.#path(path));
+      if (options.maxRetries !== void 0 && options.maxRetries !== 0) unsupported("rmdir retries");
+      if (options.retryDelay !== void 0) unsupported("rmdir retryDelay");
+      const method = this.#fs.rmdir;
+      if (method === void 0) unsupported("atomic rmdir");
+      await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], signal), void 0, [0]);
+    } else await this.rm(path, options);
+  }
+  async rename(source, destination) {
+    await this.#call([source, destination], (signal, resolved) => this.#fs.rename(resolved[0], resolved[1], signal), void 0, [0, 1]);
+  }
+  async copyFile(source, destination, mode2 = 0) {
+    if (mode2 !== 0 && mode2 !== 1) unsupported("copyFile mode");
+    await this.#call([source, destination], (signal, resolved) => this.#fs.copyFile(resolved[0], resolved[1], { ...signal, exclusive: mode2 === 1 }));
+  }
+  async cp(source, destination, value) {
+    const options = optionsRecord(value, ["recursive", "force", "errorOnExist", "mode", "dereference", "preserveTimestamps", "verbatimSymlinks"]);
+    if (booleanValue(options.dereference) || booleanValue(options.preserveTimestamps) || booleanValue(options.verbatimSymlinks)) unsupported("cp options");
+    const recursive = booleanValue(options.recursive);
+    const force = booleanValue(options.force, true);
+    const errorOnExist = booleanValue(options.errorOnExist);
+    if (options.mode !== void 0 && options.mode !== 0 && options.mode !== 1) unsupported("cp mode");
+    const from = this.#path(source);
+    const to = this.#path(destination);
+    const canonicalFrom = await this.realpath(from);
+    let ancestor = to === this.#cwd ? to : this.#primitives.paths.dirname(to);
+    let canonicalAncestor;
+    while (true) {
+      try {
+        canonicalAncestor = await this.realpath(ancestor);
+        break;
+      } catch (error) {
+        if (!hasCode2(error, "ENOENT")) throw error;
+        const parent = this.#primitives.paths.dirname(ancestor);
+        if (parent === ancestor) throw error;
+        ancestor = parent;
+      }
+    }
+    const canonicalTo = this.#primitives.paths.resolve(canonicalAncestor, this.#primitives.paths.relative(ancestor, to));
+    if (canonicalFrom === "/" || canonicalTo === canonicalFrom || canonicalTo.startsWith(`${canonicalFrom}/`)) throw fsError("EINVAL", "cp", to);
+    const copy = async (current, target) => {
+      const sourceStat = await this.lstat(current);
+      if (sourceStat.isSymbolicLink()) unsupported("cp symlink");
+      let destinationStat;
+      try {
+        destinationStat = await this.lstat(target);
+      } catch (error) {
+        if (!hasCode2(error, "ENOENT")) throw error;
+      }
+      if (destinationStat?.isSymbolicLink()) unsupported("cp destination symlink");
+      if (sourceStat.isDirectory()) {
+        if (!recursive) throw fsError("EISDIR", "cp", current);
+        if (destinationStat !== void 0 && !destinationStat.isDirectory()) throw fsError("ENOTDIR", "cp", target);
+        await this.mkdir(target, { recursive: true, mode: sourceStat.mode & 4095 });
+        for (const entry of await this.readdir(current)) await copy(childPath(current, entry), childPath(target, entry));
+      } else {
+        if (destinationStat?.isDirectory()) throw fsError("EISDIR", "cp", target);
+        if (destinationStat !== void 0 && !force) {
+          if (errorOnExist) throw fsError("EEXIST", "cp", target);
+          return;
+        }
+        await this.mkdir(this.#primitives.paths.dirname(target), { recursive: true });
+        await this.copyFile(current, target, options.mode === 1 || !force ? 1 : 0);
+      }
+    };
+    await copy(from, to);
+  }
+  async readlink(path, value) {
+    const codec = this.#encoding(optionsRecord(value, ["encoding"]).encoding, "utf8", true);
+    const method = this.#fs.readlink;
+    if (method === void 0) unsupported("readlink");
+    const target = await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], signal), void 0, [0]);
+    return codec === "buffer" ? this.#textBytes(target) : this.#codec.decode(this.#textBytes(target), codec);
+  }
+  async realpath(path, value) {
+    const codec = this.#encoding(optionsRecord(value, ["encoding"]).encoding, "utf8", true);
+    const target = await this.#call([path], (signal, resolved) => this.#fs.realpath(resolved[0], signal));
+    assertBridgePath(this.#cwd, target);
+    return codec === "buffer" ? this.#textBytes(target) : this.#codec.decode(this.#textBytes(target), codec);
+  }
+  async mkdtemp(prefix, value) {
+    if (typeof prefix !== "string" || prefix.includes("\0")) throw new TypeError("Invalid mkdtemp prefix");
+    const codec = this.#encoding(optionsRecord(value, ["encoding"]).encoding, "utf8", true);
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      const path = prefix + this.#primitives.randomSuffix();
+      try {
+        await this.mkdir(path, { mode: 448 });
+        return codec === "buffer" ? this.#textBytes(path) : this.#codec.decode(this.#textBytes(path), codec);
+      } catch (error) {
+        if (!hasCode2(error, "EEXIST")) throw error;
+      }
+    }
+    throw fsError("EEXIST", "mkdtemp", prefix);
+  }
+  async symlink(target, path, type) {
+    if (type !== void 0 && type !== null && type !== "file" && type !== "dir") unsupported("symlink type");
+    const linkTarget = this.#primitives.pathValue === void 0 ? target : this.#primitives.pathValue(target);
+    if (typeof linkTarget !== "string" || linkTarget.includes("\0")) throw new TypeError("Invalid symlink target");
+    const destination = this.#path(path);
+    const absoluteTarget = this.#path(this.#primitives.paths.isAbsolute(linkTarget) ? linkTarget : childPath(this.#primitives.paths.dirname(destination), linkTarget));
+    if (this.#cwd !== "/" && this.#primitives.paths.isAbsolute(linkTarget)) {
+      throw fsError("ENOTSUP", "symlink", destination);
+    }
+    const method = this.#fs.symlink;
+    if (method === void 0) unsupported("symlink");
+    await this.#call([destination, absoluteTarget], (signal, resolved) => method.call(this.#fs, linkTarget, resolved[0], signal), void 0, [0]);
+  }
+  async link(existing, path) {
+    const method = this.#fs.link;
+    if (method === void 0) unsupported("link");
+    await this.#call([existing, path], (signal, resolved) => method.call(this.#fs, resolved[0], resolved[1], signal), void 0, [1]);
+  }
+  async chmod(path, value) {
+    const mode2 = modeValue(value, 0);
+    const method = this.#fs.chmod;
+    if (method === void 0) unsupported("chmod");
+    await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], mode2, signal));
+  }
+  async utimes(path, atime, mtime) {
+    const accessTime = timeValue(atime);
+    const modificationTime = timeValue(mtime);
+    const method = this.#fs.utimes;
+    if (method === void 0) unsupported("utimes");
+    await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], accessTime, modificationTime, signal));
+  }
+  async truncate(path, length = 0) {
+    if (!Number.isInteger(length)) throw new TypeError("Invalid truncate length");
+    const method = this.#fs.truncate;
+    if (method === void 0) unsupported("truncate");
+    await this.#call([path], (signal, resolved) => method.call(this.#fs, resolved[0], Math.max(0, length), signal));
+  }
+};
+
+// packages/safe-fs/src/bridge/index.ts
+function createFsBridge(fs, options) {
+  if (options === void 0 || options === null) throw new TypeError("An explicit filesystem codec is required");
+  return new FileSystemBridge(fs, options, {
+    codec: options.codec,
+    copyBytes(bytes) {
+      return new Uint8Array(bytes);
+    },
+    randomSuffix() {
+      return platform.randomUUID().slice(0, 6);
+    },
+    paths: {
+      isAbsolute(path) {
+        return typeof path === "string" && path.startsWith("/");
+      },
+      dirname,
+      relative: relativePath,
+      resolve: resolvePath
+    }
+  });
+}
+
+export {
+  FsError,
+  isErrnoCode,
+  isFsError,
+  toFsError,
+  ACCESS_MODES,
+  toByteSource,
+  collectBytes,
+  readBytes,
+  validatePath,
+  resolvePath,
+  normalizePath,
+  relativePath,
+  isPathWithin,
+  assertPathWithin,
+  basename,
+  dirname2 as dirname,
+  extname,
+  isAbsolutePath,
+  joinPath,
+  posixPath,
+  compareEntries,
+  MemoryFileSystem,
+  createMemoryFileSystem,
+  ReadOnlyFileSystem,
+  createReadOnlyFileSystem,
+  MountFileSystem,
+  createMountFileSystem,
+  OverlayFileSystem,
+  createOverlayFileSystem,
+  WebDavFileSystem,
+  createFsBridge
+};
+//# sourceMappingURL=chunk-QGN6DKT5.js.map