@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash-mcp/index.js

@@ -236,6 +236,7 @@ function snapshotLoopbackAuthorizationOptions(options) {
     ...options,
     openBrowser: options.openBrowser?.bind(options),
     readLine: options.readLine?.bind(options),
+    waitForCallback: options.waitForCallback?.bind(options),
     createServer: options.createServer?.bind(options),
     callbackPath: options.callbackPath,
     redirectUri: options.redirectUri,
@@ -250,6 +251,8 @@ async function createLoopbackAuthorizationSession(options = {}) {
   const timeoutMs = options.timeoutMs ?? 12e4;
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
     throw new Error("OAuth authorization timeoutMs must be a positive supported timer interval");
+  if (options.waitForCallback !== void 0)
+    return createHostedAuthorizationSession(options, timeoutMs);
   const target = loopbackTarget(options);
   const server = options.createServer ? options.createServer() : http.createServer();
   const controller = new AbortController();
@@ -315,6 +318,79 @@ function loopbackTarget(options) {
     throw new Error("Invalid OAuth loopback callback path");
   return { port: 0, host: "127.0.0.1", callbackPath };
 }
+function validateAuthorizationRedirect(options) {
+  if (options.waitForCallback === void 0) {
+    loopbackTarget(options);
+    return;
+  }
+  if (typeof options.waitForCallback !== "function" || options.redirectUri === void 0)
+    throw new Error("Hosted OAuth callbacks require redirectUri and waitForCallback");
+  validateHostedOAuthRedirect(options.redirectUri, options.callbackPath);
+}
+function validateHostedOAuthRedirect(redirectUri, callbackPath) {
+  const url = new URL(redirectUri);
+  if (url.protocol !== "https:" || url.username || url.password || url.href.includes("#") || url.port === "0" || oauthCallbackParameters.some((name) => url.searchParams.has(name)) || [...redirectUri].some((char) => char.codePointAt(0) <= 32) || callbackPath !== void 0 && callbackPath !== url.pathname)
+    throw new Error("Invalid hosted OAuth redirect URI");
+}
+function createHostedAuthorizationSession(options, timeoutMs) {
+  validateAuthorizationRedirect(options);
+  const redirectUri = options.redirectUri, controller = new AbortController();
+  let used = false;
+  const aborted = () => controller.abort(options.signal?.reason);
+  const timer = setTimeout(() => controller.abort(new Error("OAuth authorization timed out")), timeoutMs);
+  timer.unref?.();
+  const cleanup = () => {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", aborted);
+  };
+  controller.signal.addEventListener("abort", cleanup, { once: true });
+  options.signal?.addEventListener("abort", aborted, { once: true });
+  if (options.signal?.aborted)
+    aborted();
+  return {
+    redirectUri,
+    async waitForCode(authorizationUrl) {
+      controller.signal.throwIfAborted();
+      if (used)
+        throw new Error("OAuth authorization session has already been used");
+      used = true;
+      try {
+        const authorization = new URL(authorizationUrl);
+        if (authorization.searchParams.getAll("redirect_uri").length !== 1 || authorization.searchParams.get("redirect_uri") !== redirectUri)
+          throw new Error("OAuth authorization redirect mismatch");
+        const callback = await new Promise((resolve, reject) => {
+          const onAbort = () => reject(controller.signal.reason);
+          controller.signal.addEventListener("abort", onAbort, { once: true });
+          void Promise.resolve().then(() => {
+            controller.signal.throwIfAborted();
+            return options.waitForCallback({ authorizationUrl, redirectUri, signal: controller.signal });
+          }).then(resolve, reject).finally(() => controller.signal.removeEventListener("abort", onAbort));
+        });
+        controller.signal.throwIfAborted();
+        const url = new URL(callback), base = new URL(redirectUri);
+        if (url.origin !== base.origin || url.pathname !== base.pathname || url.username || url.password || url.href.includes("#") || [...callback].some((char) => char.codePointAt(0) <= 32))
+          throw new Error("OAuth callback redirect mismatch");
+        const params = readAuthorizationCallbackParameters(url);
+        for (const name of oauthCallbackParameters)
+          url.searchParams.delete(name);
+        if (url.searchParams.toString() !== base.searchParams.toString())
+          throw new Error("OAuth callback redirect mismatch");
+        const expected = readExpectedAuthorizationCallback(authorizationUrl);
+        if (expected.state === null)
+          throw new Error("OAuth authorization missing state");
+        validateAuthorizationCallbackBinding(params, expected);
+        if (params.error !== null)
+          throw new OAuthAuthorizationError(params.error, params.errorDescription ?? params.error);
+        return validateAuthorizationCallbackParameters(params, expected);
+      } finally {
+        controller.abort(new Error("OAuth authorization session closed"));
+      }
+    },
+    close() {
+      controller.abort(new Error("OAuth authorization session closed"));
+    }
+  };
+}
 async function startServer(server, port, host, signal) {
   signal.throwIfAborted();
   return new Promise((resolve, reject) => {
@@ -574,7 +650,10 @@ function normalizeStoredOAuthClient(value) {
     try {
       if (typeof requestedRedirectUri !== "string")
         throw new Error("Invalid redirect identity");
-      loopbackTarget({ redirectUri: requestedRedirectUri });
+      if (new URL(requestedRedirectUri).protocol === "https:")
+        validateHostedOAuthRedirect(requestedRedirectUri);
+      else
+        loopbackTarget({ redirectUri: requestedRedirectUri });
     } catch {
       throw new Error("Invalid stored OAuth registration redirect identity");
     }
@@ -1470,7 +1549,7 @@ function isStoredOAuthTokensOrMissing(value) {
     return false;
   }
   const scope = getOwnEntry4(value, "scope");
-  return scope === void 0 || typeof scope === "string" && scope.trim().length > 0;
+  return scope === void 0 || scope === "" || typeof scope === "string" && scope.trim().length > 0;
 }
 function isNonBlankOwnString(record3, key2) {
   const value = getOwnString(record3, key2);
@@ -1891,7 +1970,7 @@ async function requestTokens(input) {
     throw new Error("OAuth token response has invalid refresh_token");
   const scope = getOwnEntry5(payload, "scope");
   const normalizedRefreshToken = typeof refreshToken === "string" && refreshToken.trim().length > 0 ? refreshToken.trim() : void 0;
-  const normalizedScope = normalizeOAuthScope(scope);
+  const normalizedScope = scope === "" ? "" : normalizeOAuthScope(scope);
   if (scope !== void 0 && normalizedScope === void 0)
     throw new Error("Invalid OAuth scope syntax in token response");
   return {
@@ -2018,7 +2097,7 @@ function createDefaultOAuthClientProvider(options) {
   const clientMode = options.client.mode;
   const interactiveEnabled = options.allowInteractive !== false;
   const sessionLockTimeoutMs = options.sessionLockTimeoutMs;
-  loopbackTarget(browser);
+  validateAuthorizationRedirect(browser);
   assertPersistenceNamespace(options.persistenceNamespace);
   const clientMetadata = getClientMetadata(options.client);
   const requestedScope = clientMetadata?.scope;
@@ -2612,7 +2691,7 @@ function normalizeStoredTokens(value) {
   const scope = getOwnEntry6(value, "scope");
   const normalizedAccessToken = accessToken?.trim();
   const normalizedRefreshToken = typeof refreshToken === "string" ? refreshToken.trim() : void 0;
-  const normalizedScope = normalizeOAuthScope(scope);
+  const normalizedScope = scope === "" ? "" : normalizeOAuthScope(scope);
   if (accessToken === void 0 || normalizedAccessToken === void 0 || normalizedAccessToken.length === 0 || tokenType !== "Bearer" || !(expiresAt === null || typeof expiresAt === "number" && Number.isSafeInteger(expiresAt) && expiresAt <= MAX_JS_DATE_MS3 && Number.isFinite(new Date(expiresAt).getTime())) || refreshToken !== void 0 && (typeof refreshToken !== "string" || normalizedRefreshToken === void 0 || normalizedRefreshToken.length === 0)) {
     return void 0;
   }
@@ -2621,7 +2700,7 @@ function normalizeStoredTokens(value) {
     tokenType,
     expiresAt,
     ...normalizedRefreshToken === void 0 ? {} : { refreshToken: normalizedRefreshToken },
-    ...normalizedScope === void 0 || normalizedScope.length === 0 ? {} : { scope: normalizedScope }
+    ...normalizedScope === void 0 ? {} : { scope: normalizedScope }
   };
 }
 function getClientMetadata(client) {
@@ -2841,6 +2920,7 @@ function snapshotOAuthBrowserOptions(browser) {
     ...browser,
     openBrowser: browser.openBrowser?.bind(browser),
     readLine: browser.readLine?.bind(browser),
+    waitForCallback: browser.waitForCallback?.bind(browser),
     createServer: browser.createServer?.bind(browser),
     redirectUri: browser.redirectUri,
     signal: browser.signal,
@@ -6221,9 +6301,9 @@ var SubscriptionManager = class {
     let canceled = false;
     let acknowledge;
     let reject;
-    const acknowledged = new Promise((resolve, fail2) => {
+    const acknowledged = new Promise((resolve, fail3) => {
       acknowledge = resolve;
-      reject = fail2;
+      reject = fail3;
     });
     const cancel = () => {
       if (canceled) return;
@@ -6452,6 +6532,7 @@ function snapshotLoopbackAuthorizationOptions2(options) {
     ...options,
     openBrowser: options.openBrowser?.bind(options),
     readLine: options.readLine?.bind(options),
+    waitForCallback: options.waitForCallback?.bind(options),
     createServer: options.createServer?.bind(options),
     callbackPath: options.callbackPath,
     redirectUri: options.redirectUri,
@@ -6466,6 +6547,8 @@ async function createLoopbackAuthorizationSession2(options = {}) {
   const timeoutMs = options.timeoutMs ?? 12e4;
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
     throw new Error("OAuth authorization timeoutMs must be a positive supported timer interval");
+  if (options.waitForCallback !== void 0)
+    return createHostedAuthorizationSession2(options, timeoutMs);
   const target = loopbackTarget2(options);
   const server = options.createServer ? options.createServer() : http2.createServer();
   const controller = new AbortController();
@@ -6531,6 +6614,79 @@ function loopbackTarget2(options) {
     throw new Error("Invalid OAuth loopback callback path");
   return { port: 0, host: "127.0.0.1", callbackPath };
 }
+function validateAuthorizationRedirect2(options) {
+  if (options.waitForCallback === void 0) {
+    loopbackTarget2(options);
+    return;
+  }
+  if (typeof options.waitForCallback !== "function" || options.redirectUri === void 0)
+    throw new Error("Hosted OAuth callbacks require redirectUri and waitForCallback");
+  validateHostedOAuthRedirect2(options.redirectUri, options.callbackPath);
+}
+function validateHostedOAuthRedirect2(redirectUri, callbackPath) {
+  const url = new URL(redirectUri);
+  if (url.protocol !== "https:" || url.username || url.password || url.href.includes("#") || url.port === "0" || oauthCallbackParameters2.some((name) => url.searchParams.has(name)) || [...redirectUri].some((char) => char.codePointAt(0) <= 32) || callbackPath !== void 0 && callbackPath !== url.pathname)
+    throw new Error("Invalid hosted OAuth redirect URI");
+}
+function createHostedAuthorizationSession2(options, timeoutMs) {
+  validateAuthorizationRedirect2(options);
+  const redirectUri = options.redirectUri, controller = new AbortController();
+  let used = false;
+  const aborted = () => controller.abort(options.signal?.reason);
+  const timer = setTimeout(() => controller.abort(new Error("OAuth authorization timed out")), timeoutMs);
+  timer.unref?.();
+  const cleanup = () => {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", aborted);
+  };
+  controller.signal.addEventListener("abort", cleanup, { once: true });
+  options.signal?.addEventListener("abort", aborted, { once: true });
+  if (options.signal?.aborted)
+    aborted();
+  return {
+    redirectUri,
+    async waitForCode(authorizationUrl) {
+      controller.signal.throwIfAborted();
+      if (used)
+        throw new Error("OAuth authorization session has already been used");
+      used = true;
+      try {
+        const authorization = new URL(authorizationUrl);
+        if (authorization.searchParams.getAll("redirect_uri").length !== 1 || authorization.searchParams.get("redirect_uri") !== redirectUri)
+          throw new Error("OAuth authorization redirect mismatch");
+        const callback = await new Promise((resolve, reject) => {
+          const onAbort = () => reject(controller.signal.reason);
+          controller.signal.addEventListener("abort", onAbort, { once: true });
+          void Promise.resolve().then(() => {
+            controller.signal.throwIfAborted();
+            return options.waitForCallback({ authorizationUrl, redirectUri, signal: controller.signal });
+          }).then(resolve, reject).finally(() => controller.signal.removeEventListener("abort", onAbort));
+        });
+        controller.signal.throwIfAborted();
+        const url = new URL(callback), base = new URL(redirectUri);
+        if (url.origin !== base.origin || url.pathname !== base.pathname || url.username || url.password || url.href.includes("#") || [...callback].some((char) => char.codePointAt(0) <= 32))
+          throw new Error("OAuth callback redirect mismatch");
+        const params = readAuthorizationCallbackParameters2(url);
+        for (const name of oauthCallbackParameters2)
+          url.searchParams.delete(name);
+        if (url.searchParams.toString() !== base.searchParams.toString())
+          throw new Error("OAuth callback redirect mismatch");
+        const expected = readExpectedAuthorizationCallback2(authorizationUrl);
+        if (expected.state === null)
+          throw new Error("OAuth authorization missing state");
+        validateAuthorizationCallbackBinding2(params, expected);
+        if (params.error !== null)
+          throw new OAuthAuthorizationError2(params.error, params.errorDescription ?? params.error);
+        return validateAuthorizationCallbackParameters2(params, expected);
+      } finally {
+        controller.abort(new Error("OAuth authorization session closed"));
+      }
+    },
+    close() {
+      controller.abort(new Error("OAuth authorization session closed"));
+    }
+  };
+}
 async function startServer2(server, port, host, signal) {
   signal.throwIfAborted();
   return new Promise((resolve, reject) => {
@@ -6786,7 +6942,10 @@ function normalizeStoredOAuthClient2(value) {
     try {
       if (typeof requestedRedirectUri !== "string")
         throw new Error("Invalid redirect identity");
-      loopbackTarget2({ redirectUri: requestedRedirectUri });
+      if (new URL(requestedRedirectUri).protocol === "https:")
+        validateHostedOAuthRedirect2(requestedRedirectUri);
+      else
+        loopbackTarget2({ redirectUri: requestedRedirectUri });
     } catch {
       throw new Error("Invalid stored OAuth registration redirect identity");
     }
@@ -7651,7 +7810,7 @@ function isStoredOAuthTokensOrMissing2(value) {
     return false;
   }
   const scope = getOwnEntry42(value, "scope");
-  return scope === void 0 || typeof scope === "string" && scope.trim().length > 0;
+  return scope === void 0 || scope === "" || typeof scope === "string" && scope.trim().length > 0;
 }
 function isNonBlankOwnString2(record22, key2) {
   const value = getOwnString3(record22, key2);
@@ -8055,7 +8214,7 @@ async function requestTokens2(input) {
     throw new Error("OAuth token response has invalid refresh_token");
   const scope = getOwnEntry52(payload, "scope");
   const normalizedRefreshToken = typeof refreshToken === "string" && refreshToken.trim().length > 0 ? refreshToken.trim() : void 0;
-  const normalizedScope = normalizeOAuthScope2(scope);
+  const normalizedScope = scope === "" ? "" : normalizeOAuthScope2(scope);
   if (scope !== void 0 && normalizedScope === void 0)
     throw new Error("Invalid OAuth scope syntax in token response");
   return {
@@ -8184,7 +8343,7 @@ function createDefaultOAuthClientProvider2(options) {
   const clientMode = options.client.mode;
   const interactiveEnabled = options.allowInteractive !== false;
   const sessionLockTimeoutMs = options.sessionLockTimeoutMs;
-  loopbackTarget2(browser);
+  validateAuthorizationRedirect2(browser);
   assertPersistenceNamespace2(options.persistenceNamespace);
   const clientMetadata = getClientMetadata2(options.client);
   const requestedScope = clientMetadata?.scope;
@@ -8781,7 +8940,7 @@ function normalizeStoredTokens2(value) {
   const scope = getOwnEntry62(value, "scope");
   const normalizedAccessToken = accessToken?.trim();
   const normalizedRefreshToken = typeof refreshToken === "string" ? refreshToken.trim() : void 0;
-  const normalizedScope = normalizeOAuthScope2(scope);
+  const normalizedScope = scope === "" ? "" : normalizeOAuthScope2(scope);
   if (accessToken === void 0 || normalizedAccessToken === void 0 || normalizedAccessToken.length === 0 || tokenType !== "Bearer" || !(expiresAt === null || typeof expiresAt === "number" && Number.isSafeInteger(expiresAt) && expiresAt <= MAX_JS_DATE_MS32 && Number.isFinite(new Date(expiresAt).getTime())) || refreshToken !== void 0 && (typeof refreshToken !== "string" || normalizedRefreshToken === void 0 || normalizedRefreshToken.length === 0)) {
     return void 0;
   }
@@ -8790,7 +8949,7 @@ function normalizeStoredTokens2(value) {
     tokenType,
     expiresAt,
     ...normalizedRefreshToken === void 0 ? {} : { refreshToken: normalizedRefreshToken },
-    ...normalizedScope === void 0 || normalizedScope.length === 0 ? {} : { scope: normalizedScope }
+    ...normalizedScope === void 0 ? {} : { scope: normalizedScope }
   };
 }
 function getClientMetadata2(client) {
@@ -14053,6 +14212,14 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import * as util from "node:util";
 import { constants } from "node:os";
+
+// ../safe-fs/dist/platform/transport-budget.js
+var hasRegisteredS3FileSystem = false;
+function enableS3TransportBudget() {
+  hasRegisteredS3FileSystem = true;
+}
+
+// ../safe-fs/dist/platform/node.js
 var systemErrnos = (() => {
   const fallback = new Map(Object.entries(constants.errno).map(([name, errno]) => [name, -Math.abs(errno)]));
   if (typeof util.getSystemErrorMap !== "function")
@@ -14085,6 +14252,19 @@ var comparisonContext = Object.freeze({
   }
 });
 var transportBudgets = new AsyncLocalStorage();
+function chargeScopedTransportCall(options) {
+  if (!hasRegisteredS3FileSystem)
+    return;
+  const frames = transportBudgets.getStore();
+  if (!frames)
+    return;
+  for (const frame of frames) {
+    if (frame.credit > 0)
+      frame.credit--;
+    else
+      frame.admit(options);
+  }
+}
 
 // ../safe-fs/dist/contracts/errors.js
 var descriptions = {
@@ -14196,6 +14376,48 @@ var EMPTY_BYTE_SOURCE = Object.freeze({
 });
 var noop = () => {
 };
+async function collectBytes2(source, options) {
+  if (options.maxBytes !== void 0 && options.maxBytes !== Infinity && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)) {
+    throw new RangeError("maxBytes must be a nonnegative safe integer");
+  }
+  if (options.maxMemoryBytes !== void 0 && options.maxMemoryBytes !== Infinity && (!Number.isSafeInteger(options.maxMemoryBytes) || options.maxMemoryBytes < 0)) {
+    throw new RangeError("maxMemoryBytes must be a nonnegative safe integer or Infinity");
+  }
+  const memoryLimit = options.maxMemoryBytes ?? Infinity;
+  let reserved = 0;
+  let inputBytes = 0;
+  let buffer = new Uint8Array(0);
+  let size = 0;
+  function reserve(bytes) {
+    if (bytes > memoryLimit - reserved) {
+      throw new FsError("EFBIG", { syscall: "collectBytes", message: "collection exceeds memory budget" });
+    }
+    reserved += bytes;
+  }
+  options.signal?.throwIfAborted();
+  for await (const chunk of readBytes(source, options.signal)) {
+    reserved -= inputBytes;
+    inputBytes = 0;
+    if (chunk.byteLength > (options.maxBytes ?? Infinity) - size) {
+      throw new FsError("EFBIG", { syscall: "collectBytes", message: "output exceeds maxBytes" });
+    }
+    reserve(chunk.buffer.byteLength);
+    inputBytes = chunk.buffer.byteLength;
+    const nextSize = size + chunk.byteLength;
+    if (nextSize > buffer.byteLength) {
+      const capacity = Math.min(options.maxBytes ?? Infinity, Math.max(nextSize, buffer.byteLength * 2));
+      reserve(capacity);
+      const replacement = new Uint8Array(capacity);
+      replacement.set(buffer.subarray(0, size));
+      reserved -= buffer.byteLength;
+      buffer = replacement;
+    }
+    buffer.set(chunk, size);
+    size = nextSize;
+  }
+  options.signal?.throwIfAborted();
+  return buffer.subarray(0, size);
+}
 async function abortable(operation, signal) {
   signal?.throwIfAborted();
   if (!signal)
@@ -14955,10 +15177,76 @@ async function compareEntries(filesystem, path6, peer, peerPath, options = {}) {
 }
 
 // ../safe-fs/dist/fs/s3/registry.js
+var observedStats = /* @__PURE__ */ new WeakMap();
 var entries = /* @__PURE__ */ new WeakMap();
+var comparisons = /* @__PURE__ */ new WeakMap();
+var configuredComparisons = /* @__PURE__ */ new WeakMap();
+function recordS3Observation(filesystem, path6, stat, entry) {
+  observedStats.set(stat, { filesystem, path: path6, entry });
+}
+function registerS3EntryOwner(filesystem, normalize2, intact, baseComparison, comparison) {
+  enableS3TransportBudget();
+  comparisons.set(filesystem, baseComparison);
+  if (comparison)
+    configuredComparisons.set(filesystem, comparison);
+  entries.set(filesystem, (view) => {
+    if (!intact())
+      return void 0;
+    const observation = observedStats.get(view.stat);
+    return observation?.filesystem === filesystem && observation.path === normalize2(view.path) ? observation.entry : void 0;
+  });
+}
 function getOwnedS3Entry(view) {
   return entries.get(view.filesystem)?.(view);
 }
+async function compareOwnedS3Entries(own, peer, options) {
+  options.signal?.throwIfAborted();
+  let explicit = false;
+  let answer = "unknown";
+  const visited = /* @__PURE__ */ new Set();
+  for (const [left2, right2] of [[own, peer], [peer, own]]) {
+    const baseComparison = comparisons.get(left2.filesystem);
+    if (!baseComparison || visited.has(left2.filesystem))
+      continue;
+    visited.add(left2.filesystem);
+    const current = left2.filesystem.compareEntry;
+    const comparison = current === baseComparison ? configuredComparisons.get(left2.filesystem) : current;
+    if (current === baseComparison && comparison === void 0)
+      continue;
+    explicit = true;
+    if (comparison === void 0)
+      continue;
+    options.signal?.throwIfAborted();
+    if (typeof comparison !== "function") {
+      throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid explicit S3 comparison method" });
+    }
+    assertCallbackAuthorityAllowed();
+    const result = await comparison.call(left2.filesystem, left2.path, right2.filesystem, right2.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 S3 comparison" });
+    }
+    if (result === "unknown")
+      continue;
+    if (answer !== "unknown" && answer !== result) {
+      throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting explicit S3 comparisons" });
+    }
+    answer = result;
+  }
+  const left = getOwnedS3Entry(own);
+  options.signal?.throwIfAborted();
+  const right = getOwnedS3Entry(peer);
+  options.signal?.throwIfAborted();
+  const same = left && right && left.storage === right.storage && left.key === right.key;
+  if (same && answer === "distinct") {
+    throw new FsError("EIO", { path: own.path, dest: peer.path, message: "explicit S3 comparison contradicts a known alias" });
+  }
+  if (same)
+    return "same";
+  if (explicit)
+    return answer;
+  return left && right ? "distinct" : "unknown";
+}
 
 // ../safe-fs/dist/fs/webdav/resource-id.js
 var responses = /* @__PURE__ */ new WeakMap();
@@ -14976,10 +15264,10 @@ function ownedResponseIdentifier(response, path6) {
   return responses.get(response)?.get(path6)?.identifier;
 }
 var queries = /* @__PURE__ */ new WeakMap();
-var comparisons = /* @__PURE__ */ new WeakMap();
+var comparisons2 = /* @__PURE__ */ new WeakMap();
 var callbacks = /* @__PURE__ */ new WeakMap();
 function registerResourceQuery(filesystem, query, baseComparison, callback) {
-  comparisons.set(filesystem, baseComparison);
+  comparisons2.set(filesystem, baseComparison);
   if (callback)
     callbacks.set(filesystem, callback);
   queries.set(filesystem, async (path6, options) => {
@@ -15007,7 +15295,7 @@ var compareWebDavResources = async (own, peer, options) => {
   let answer = "unknown";
   const visited = /* @__PURE__ */ new Set();
   for (const [left, right] of [[own, peer], [peer, own]]) {
-    const baseComparison = comparisons.get(left.filesystem);
+    const baseComparison = comparisons2.get(left.filesystem);
     if (!baseComparison)
       continue;
     const method = left.filesystem.compareEntry;
@@ -15249,7 +15537,7 @@ function components(path6, signal) {
   return result;
 }
 function resolveMissingTarget(root, path6, signal) {
-  const fail2 = (code, failedPath = path6) => {
+  const fail3 = (code, failedPath = path6) => {
     throw new FsError(code, { syscall: "realpath", path: failedPath });
   };
   const origin = components(path6, signal);
@@ -15279,9 +15567,9 @@ function resolveMissingTarget(root, path6, signal) {
       }
       const current = position.node;
       if (current.type !== "directory")
-        return fail2("ENOTDIR");
+        return fail3("ENOTDIR");
       if ((current.mode >> 6 & 1) !== 1)
-        return fail2("EACCES");
+        return fail3("EACCES");
       const name = component.name;
       if (name === ".") {
         first = false;
@@ -15293,7 +15581,7 @@ function resolveMissingTarget(root, path6, signal) {
         continue;
       }
       if (exceedsComponentByteLimit(name))
-        return fail2("ENAMETOOLONG");
+        return fail3("ENAMETOOLONG");
       const node = current.entries.get(name);
       if (!node) {
         found = false;
@@ -15304,7 +15592,7 @@ function resolveMissingTarget(root, path6, signal) {
       first = false;
       if (node.type === "symlink") {
         if (++links > 40)
-          return fail2("ELOOP");
+          return fail3("ELOOP");
         const names2 = components(node.target, signal);
         if (node.target.endsWith("/"))
           names2.push({ name: ".", start: node.target.length });
@@ -15326,7 +15614,7 @@ function resolveMissingTarget(root, path6, signal) {
     for (let count = origin.length; count > missing; count--) {
       signal?.throwIfAborted();
       if (count === missing + 1 && path6[end - 1] !== "/")
-        return fail2("ENOENT", path6.slice(0, end));
+        return fail3("ENOENT", path6.slice(0, end));
       const last = origin[count - 1];
       if (!last)
         break;
@@ -19245,7 +19533,7 @@ function qualifiedNameSync(name, cache) {
   }
   return parts;
 }
-function* entities(text) {
+function* entities(text, recover) {
   let result = "";
   let offset = 0;
   while (offset < text.length) {
@@ -19254,8 +19542,12 @@ function* entities(text) {
       return result + text.slice(offset);
     result += text.slice(offset, start);
     const end = yield* find(text, ";", start + 1);
-    if (end < 0)
-      invalid("unterminated entity");
+    if (end < 0) {
+      if (!recover)
+        invalid("unterminated entity");
+      recover("unterminated entity");
+      return result + text.slice(start + 1);
+    }
     const entity = text.slice(start + 1, end);
     const predefined = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
     if (Object.hasOwn(predefined, entity))
@@ -19263,8 +19555,13 @@ function* entities(text) {
     else {
       const hexadecimal = entity.startsWith("#x");
       const digits = entity.slice(hexadecimal ? 2 : 1);
-      if (!entity.startsWith("#") || !digits.length)
-        invalid("undeclared entity");
+      if (!entity.startsWith("#") || !digits.length) {
+        if (!recover)
+          invalid("undeclared entity");
+        recover("undeclared entity");
+        offset = end + 1;
+        continue;
+      }
       let point = 0;
       for (let index = 0; index < digits.length; index++) {
         const code = digits.charCodeAt(index);
@@ -19463,7 +19760,7 @@ function* parseXmlSteps(input, limits = {}) {
       }
       if (text.indexOf("]]>") >= 0)
         invalid("CDATA terminator in text");
-      const resolved = stack.length ? text.indexOf("&") < 0 ? (pendingWork += text.length, text) : yield* entities(text) : text;
+      const resolved = stack.length ? text.indexOf("&") < 0 ? (pendingWork += text.length, text) : yield* entities(text, limits.recover) : text;
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -19571,8 +19868,11 @@ function* parseXmlSteps(input, limits = {}) {
         yield 512;
         pendingWork -= 512;
       }
-      if (source[offset++] !== ">" || stack.pop()?.name !== name)
-        invalid("mismatched closing tag");
+      if (source[offset++] !== ">" || stack.pop()?.name !== name) {
+        if (!limits.recover)
+          invalid("mismatched closing tag");
+        limits.recover("mismatched closing tag");
+      }
     } else {
       offset++;
       const repeated = previousEmpty && source.startsWith(previousEmpty.suffix, offset) ? previousEmpty : void 0;
@@ -19596,7 +19896,7 @@ function* parseXmlSteps(input, limits = {}) {
           pendingWork -= 512;
         }
         const ch = source.charCodeAt(offset);
-        if (ch === 47 || ch === 62)
+        if (ch === 47 || ch === 62 || limits.recover && offset === source.length)
           break;
         if (ws === 0)
           invalid("attributes require whitespace");
@@ -19637,7 +19937,7 @@ function* parseXmlSteps(input, limits = {}) {
         if (raw.indexOf("<") >= 0)
           invalid("less-than in attribute");
         const normalized = /[\t\n\r]/.test(raw) ? raw.replace(/[\t\n\r]/g, " ") : raw;
-        const value = normalized.indexOf("&") < 0 ? (pendingWork += normalized.length, normalized) : yield* entities(normalized);
+        const value = normalized.indexOf("&") < 0 ? (pendingWork += normalized.length, normalized) : yield* entities(normalized, limits.recover);
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -19727,8 +20027,11 @@ function* parseXmlSteps(input, limits = {}) {
       const empty = source[offset] === "/";
       if (empty)
         offset++;
-      if (source[offset++] !== ">")
-        invalid("unterminated start tag");
+      if (source[offset++] !== ">") {
+        if (!limits.recover)
+          invalid("unterminated start tag");
+        limits.recover("unterminated start tag");
+      }
       if (empty && !attributes && name.length <= 512 && source.slice(offset - name.length - 3, offset) === `<${name}/>`)
         previousEmpty = { suffix: name + "/>", name, prefix, localName };
       if (!empty)
@@ -19739,8 +20042,13 @@ function* parseXmlSteps(input, limits = {}) {
     yield pendingWork;
     pendingWork = 0;
   }
-  if (stack.length || !root)
+  if (!root)
     invalid("incomplete document");
+  if (stack.length) {
+    if (!limits.recover)
+      invalid("incomplete document");
+    limits.recover("incomplete document");
+  }
   return root;
 }
 
@@ -21225,6 +21533,1220 @@ var WebDavFileSystem = class {
 };
 var originalWebDavComparison = WebDavFileSystem.prototype.compareEntry;
 
+// ../safe-fs/dist/fs/s3/key-order.js
+function compareKeys(left, right) {
+  const encoder = new TextEncoder();
+  const a = encoder.encode(left), b = encoder.encode(right);
+  for (let index = 0; index < Math.min(a.length, b.length); index++) {
+    const difference = a[index] - b[index];
+    if (difference)
+      return difference;
+  }
+  return a.length - b.length;
+}
+
+// ../safe-fs/dist/fs/s3/authority.js
+var queryKey = /* @__PURE__ */ Symbol("s3-head-query");
+var queries2 = /* @__PURE__ */ new WeakMap();
+var providerHeads = /* @__PURE__ */ new WeakMap();
+var acceptedHeads = /* @__PURE__ */ new WeakMap();
+async function queryS3Head(input, action) {
+  const token = Object.freeze({});
+  const query = Object.freeze({ ...input });
+  const forwarded = { ...query, [queryKey]: token };
+  queries2.set(token, query);
+  try {
+    const output = await action(forwarded);
+    acceptedHeads.delete(output);
+    const proof = providerHeads.get(output);
+    if (proof?.query === query)
+      acceptedHeads.set(output, proof.entry);
+    return output;
+  } finally {
+    queries2.delete(token);
+  }
+}
+function recordS3Stat(filesystem, path6, stat, metadata) {
+  if (!metadata)
+    return;
+  const entry = acceptedHeads.get(metadata);
+  acceptedHeads.delete(metadata);
+  if (entry)
+    recordS3Observation(filesystem, path6, stat, entry);
+}
+
+// ../safe-fs/dist/fs/s3/transport.js
+function encodeCopySource(bucket, key2) {
+  return [bucket, ...key2.split("/")].map((part) => encodeURIComponent(part).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`)).join("/");
+}
+
+// ../safe-fs/dist/fs/s3/filesystem.js
+var S3RenameError = class extends FsError {
+  phase;
+  copiedKeys;
+  deletedKeys;
+  constructor(source, destination, phase, copied, deleted, cause) {
+    super(cause.code, {
+      syscall: "rename",
+      path: source,
+      dest: destination,
+      cause,
+      message: `non-atomic S3 rename failed during ${phase}; destination copies or partial source deletions may remain`
+    });
+    this.name = "S3RenameError";
+    this.phase = phase;
+    this.copiedKeys = Object.freeze([...copied]);
+    this.deletedKeys = Object.freeze([...deleted]);
+  }
+};
+function serviceCode(error) {
+  if (typeof error !== "object" || error === null)
+    return void 0;
+  const record3 = error;
+  const value = record3.Code ?? record3.code ?? record3.name;
+  return typeof value === "string" ? value : void 0;
+}
+function translate(error, syscall, path6, precondition = "EAGAIN") {
+  if (error instanceof FsError)
+    return error;
+  const status = error?.$metadata?.httpStatusCode;
+  const name = serviceCode(error);
+  let code = "EIO";
+  if (name === "AbortError" || status === 499)
+    code = "ECANCELED";
+  else if (name === "NoSuchKey" || name === "NotFound" || name === "NoSuchBucket" || status === 404)
+    code = "ENOENT";
+  else if (["AccessDenied", "InvalidAccessKeyId", "SignatureDoesNotMatch", "ExpiredToken"].includes(name ?? "") || status === 401 || status === 403)
+    code = "EACCES";
+  else if (name === "PreconditionFailed" || status === 412)
+    code = precondition;
+  else if (name === "ConditionalRequestConflict" || name === "SlowDown" || status === 409 || status === 429 || status === 503)
+    code = "EAGAIN";
+  else if (name === "NotImplemented" || status === 501)
+    code = "ENOTSUP";
+  else if (name === "EntityTooLarge")
+    code = "EFBIG";
+  else if (name === "InvalidArgument" || name === "InvalidRequest" || status === 400)
+    code = "EINVAL";
+  else if (name === "TimeoutError" || name === "RequestTimeout" || status === 408)
+    code = "ETIMEDOUT";
+  return new FsError(code, { syscall, path: path6, cause: error });
+}
+function fail2(code, syscall, path6, message) {
+  throw new FsError(code, { syscall, path: path6, ...message === void 0 ? {} : { message } });
+}
+function validateLimit(value, name, minimum, maximum = Number.MAX_SAFE_INTEGER) {
+  if ((value !== Infinity || maximum !== Infinity) && (!Number.isSafeInteger(value) || value < minimum || value > maximum)) {
+    throw new FsError("EINVAL", { message: `${name} must be an integer from ${minimum} to ${maximum}` });
+  }
+  return value;
+}
+function utf8ByteLength3(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 128)
+      bytes += 1;
+    else if (code < 2048)
+      bytes += 2;
+    else if (code >= 55296 && code <= 56319 && i + 1 < value.length && value.charCodeAt(i + 1) >= 56320 && value.charCodeAt(i + 1) <= 57343) {
+      bytes += 4;
+      i++;
+    } else
+      bytes += 3;
+  }
+  return bytes;
+}
+function isWellFormed(value) {
+  return !/[\uD800-\uDFFF]/u.test(value);
+}
+var S3FileSystem = class {
+  async open(path6, options) {
+    options.signal?.throwIfAborted();
+    throw new FsError("ENOTSUP", { syscall: "open", path: path6 });
+  }
+  capabilities;
+  readStream;
+  writeStream;
+  transport;
+  bucket;
+  prefix;
+  allowRename;
+  pageSize;
+  maxReadBytes;
+  maxStreamBytes;
+  maxListEntries;
+  maxRequests;
+  requests = 0;
+  removalLimits;
+  removalBudgets = /* @__PURE__ */ new WeakMap();
+  constructor(options) {
+    if (!options?.transport || ["headObject", "getObject", "putObject", "deleteObject", "copyObject", "listObjectsV2"].some((method) => typeof options.transport[method] !== "function")) {
+      throw new FsError("EINVAL", { message: "an explicit six-operation S3 transport is required; no default credentials or network client are created" });
+    }
+    if (options.compareEntry !== void 0 && typeof options.compareEntry !== "function") {
+      throw new FsError("EINVAL", { message: "compareEntry must be a filesystem comparison callback" });
+    }
+    if (typeof options.bucket !== "string" || !options.bucket || /[/:\0]/.test(options.bucket)) {
+      throw new FsError("EINVAL", { message: "bucket must be a nonempty bucket name, not a URL or ARN" });
+    }
+    const prefix = options.prefix ?? "";
+    if (typeof prefix !== "string" || prefix.includes("\0") || !isWellFormed(prefix) || prefix !== "" && prefix.replace(/\/$/, "").split("/").some((part) => !part || part === "." || part === "..")) {
+      throw new FsError("EINVAL", { message: "prefix must be a canonical relative object-key prefix" });
+    }
+    this.prefix = prefix === "" || prefix.endsWith("/") ? prefix : `${prefix}/`;
+    if (utf8ByteLength3(this.prefix) > 1024)
+      throw new FsError("ENAMETOOLONG", { message: "S3 prefix exceeds 1024 UTF-8 bytes" });
+    this.transport = options.transport;
+    this.bucket = options.bucket;
+    this.allowRename = options.allowNonAtomicRename ?? true;
+    this.pageSize = validateLimit(options.pageSize ?? 1e3, "pageSize", 1, 1e3);
+    this.maxReadBytes = options.maxReadBytes === void 0 ? Infinity : validateLimit(options.maxReadBytes, "maxReadBytes", 0, Infinity);
+    this.maxStreamBytes = options.maxStreamBytes === void 0 ? Infinity : validateLimit(options.maxStreamBytes, "maxStreamBytes", 0, Infinity);
+    this.maxListEntries = options.maxListEntries === void 0 ? Infinity : validateLimit(options.maxListEntries, "maxListEntries", 1, Infinity);
+    this.maxRequests = options.maxRequests === void 0 ? Infinity : validateLimit(options.maxRequests, "maxRequests", 1, Infinity);
+    this.removalLimits = {
+      maxRequests: validateLimit(options.removalLimits?.maxRequests ?? Infinity, "removalLimits.maxRequests", 1, Infinity),
+      maxListEntries: validateLimit(options.removalLimits?.maxListEntries ?? Infinity, "removalLimits.maxListEntries", 1, Infinity),
+      maxDeleteObjects: validateLimit(options.removalLimits?.maxDeleteObjects ?? Infinity, "removalLimits.maxDeleteObjects", 1, Infinity)
+    };
+    this.capabilities = Object.freeze({
+      open: false,
+      read: true,
+      stat: true,
+      readdir: true,
+      realpath: true,
+      access: true,
+      write: true,
+      explicitDirectories: true,
+      implicitDirectories: true,
+      mkdir: true,
+      recursiveMkdir: true,
+      remove: true,
+      removeDirectory: true,
+      recursiveRemove: true,
+      copy: true,
+      readlink: false,
+      exclusiveCopy: options.transport.capabilities?.conditionalCopy === true,
+      append: options.transport.capabilities?.conditionalPut === true,
+      exclusiveCreate: options.transport.capabilities?.conditionalPut === true,
+      truncate: options.transport.capabilities?.conditionalPut === true,
+      atomicRenameNoReplace: false,
+      rename: this.allowRename && options.transport.capabilities?.conditionalDelete === true && (options.transport.capabilities?.conditionalCopy === true || options.transport.capabilities?.conditionalPut === true),
+      streamingAppend: options.transport.capabilities?.streamingWrite === true && options.transport.capabilities?.conditionalPut === true && typeof options.transport.putObjectStream === "function",
+      randomAccessWrite: false,
+      readOnly: options.readOnly ?? false,
+      symlinks: false,
+      hardlinks: false,
+      permissions: false,
+      timestamps: options.transport.capabilities?.conditionalCopy === true || options.transport.capabilities?.conditionalPut === true,
+      atomicRename: false,
+      snapshotRmdir: true,
+      streamingRead: options.transport.capabilities?.streamingRead === true && typeof options.transport.getObjectStream === "function",
+      streamingWrite: options.transport.capabilities?.streamingWrite === true && typeof options.transport.putObjectStream === "function"
+    });
+    if (this.capabilities.streamingRead)
+      this.readStream = this.streamRead.bind(this);
+    if (this.capabilities.streamingWrite)
+      this.writeStream = this.streamWrite.bind(this);
+    const transport = this.transport;
+    const bucket = this.bucket;
+    const registeredPrefix = this.prefix;
+    registerS3EntryOwner(this, (path6) => this.path(path6), () => this.transport === transport && this.bucket === bucket && this.prefix === registeredPrefix, s3Comparison, options.compareEntry);
+    registerEntryAuthority(this, compareOwnedS3Entries);
+  }
+  async compareEntry(path6, peer, peerPath, options = {}) {
+    return compareEntries(this, path6, peer, peerPath, options);
+  }
+  path(input) {
+    if (typeof input !== "string" || input.includes("\0") || !isWellFormed(input))
+      fail2("EINVAL", "resolve", input, "invalid path string");
+    const components2 = [];
+    for (const part of input.split("/")) {
+      if (!part || part === ".")
+        continue;
+      if (part === "..") {
+        if (components2.length === 0)
+          fail2("EACCES", "resolve", input, "path attempts to escape the configured prefix");
+        components2.pop();
+      } else
+        components2.push(part);
+    }
+    const path6 = `/${components2.join("/")}`;
+    if (utf8ByteLength3(this.key(path6)) > 1024)
+      fail2("ENAMETOOLONG", "resolve", input);
+    return path6;
+  }
+  key(path6) {
+    return this.prefix + path6.slice(1);
+  }
+  directoryKey(path6) {
+    const key2 = path6 === "/" ? this.prefix : `${this.key(path6)}/`;
+    if (utf8ByteLength3(key2) > 1024)
+      fail2("ENAMETOOLONG", "resolve", path6);
+    return key2;
+  }
+  checkAbort(options, syscall, path6) {
+    if (options.signal?.aborted)
+      fail2("ECANCELED", syscall, path6);
+  }
+  requestOptions(options) {
+    return options.signal === void 0 ? {} : { abortSignal: options.signal };
+  }
+  async call(syscall, path6, options, action, precondition) {
+    this.checkAbort(options, syscall, path6);
+    chargeScopedTransportCall(options);
+    this.checkAbort(options, syscall, path6);
+    const budget = this.removalBudgets.get(options);
+    if (budget && ++budget.requests > this.removalLimits.maxRequests) {
+      fail2("EFBIG", "rm", path6, "S3 removal request budget exceeded");
+    }
+    if (this.requests >= this.maxRequests) {
+      fail2("EFBIG", syscall, path6, "S3 transport request budget exceeded");
+    }
+    this.requests++;
+    let onAbort;
+    try {
+      const pending = action();
+      const result = options.signal ? await new Promise((resolve, reject) => {
+        const signal = options.signal;
+        onAbort = () => reject(new FsError("ECANCELED", { syscall, path: path6, cause: signal.reason }));
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+          onAbort();
+        pending.then((value) => {
+          if (signal.aborted && typeof value === "object" && value !== null && "Body" in value)
+            this.dispose(value.Body);
+          resolve(value);
+        }, reject);
+      }) : await pending;
+      this.checkAbort(options, syscall, path6);
+      return result;
+    } catch (error) {
+      if (options.signal?.aborted)
+        fail2("ECANCELED", syscall, path6);
+      throw translate(error, syscall, path6, precondition);
+    } finally {
+      if (onAbort)
+        options.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  writable(path6, mode) {
+    if (this.capabilities.readOnly)
+      fail2("EROFS", "write", path6);
+    if (mode !== void 0)
+      validateLimit(mode, "mode", 0, 4095);
+  }
+  unsupported(operation, path6) {
+    return fail2("ENOTSUP", operation, path6, `S3 does not support ${operation} with the configured transport`);
+  }
+  async head(key2, path6, options) {
+    try {
+      const input = { Bucket: this.bucket, Key: key2 };
+      return await this.call("headObject", path6, options, () => queryS3Head(input, (query) => this.transport.headObject(query, this.requestOptions(options))));
+    } catch (error) {
+      if (isFsError(error, "ENOENT") && serviceCode(error.cause) !== "NoSuchBucket")
+        return void 0;
+      throw error;
+    }
+  }
+  makeStat(type, metadata) {
+    const size = type === "directory" ? 0 : metadata?.ContentLength;
+    if (size === void 0 || !Number.isSafeInteger(size) || size < 0)
+      fail2("EIO", "stat", "", "transport omitted a valid object ContentLength");
+    const modified = metadata?.LastModified?.getTime() ?? 0;
+    if (!Number.isFinite(modified))
+      fail2("EIO", "stat", "", "transport returned an invalid LastModified");
+    const timestamp = (key2, fallback) => {
+      const value = metadata?.Metadata?.[key2];
+      if (value === void 0)
+        return fallback;
+      const parsed = Number(value);
+      if (!value || !Number.isFinite(parsed))
+        fail2("EIO", "stat", "", "invalid virtual timestamp metadata");
+      return parsed;
+    };
+    const storedMode = metadata?.Metadata?.["virtual-bash-mode"];
+    const mode = storedMode === void 0 ? type === "directory" ? 493 : 420 : Number(storedMode);
+    if (!Number.isSafeInteger(mode) || mode < 0 || mode > 4095 || storedMode === "")
+      fail2("EIO", "stat", "", "invalid virtual mode metadata");
+    return {
+      type,
+      size,
+      mode: (type === "directory" ? 16384 : 32768) | mode,
+      mtimeMs: timestamp("virtual-bash-mtime", modified),
+      atimeMs: timestamp("virtual-bash-atime", 0),
+      ctimeMs: modified
+    };
+  }
+  async page(prefix, path6, options, delimiter, token, maxKeys = this.pageSize) {
+    const budget = this.removalBudgets.get(options);
+    if (budget)
+      maxKeys = Math.min(maxKeys, this.removalLimits.maxListEntries - budget.entries + 1);
+    const result = await this.call("listObjectsV2", path6, options, () => this.transport.listObjectsV2({
+      Bucket: this.bucket,
+      Prefix: prefix,
+      MaxKeys: maxKeys,
+      ...delimiter === void 0 ? {} : { Delimiter: delimiter },
+      ...token === void 0 ? {} : { ContinuationToken: token }
+    }, this.requestOptions(options)));
+    if (budget) {
+      budget.entries += (result.Contents?.length ?? 0) + (result.CommonPrefixes?.length ?? 0);
+      if (budget.entries > this.removalLimits.maxListEntries)
+        fail2("EFBIG", "rm", path6, "S3 removal listing budget exceeded");
+    }
+    for (const item of result.Contents ?? []) {
+      if (typeof item.Key !== "string" || !item.Key.startsWith(prefix))
+        fail2("EIO", "listObjectsV2", path6, "transport returned an object outside the requested prefix");
+      this.validateObject(item, path6);
+    }
+    for (const item of result.CommonPrefixes ?? []) {
+      if (delimiter === void 0 || typeof item.Prefix !== "string" || !item.Prefix.startsWith(prefix) || !item.Prefix.endsWith("/") || item.Prefix === prefix)
+        fail2("EIO", "listObjectsV2", path6, "invalid common prefix");
+      this.validateKey(item.Prefix, path6);
+    }
+    if (result.IsTruncated !== void 0 && typeof result.IsTruncated !== "boolean")
+      fail2("EIO", "listObjectsV2", path6, "invalid IsTruncated flag");
+    return result;
+  }
+  validateKey(key2, path6) {
+    if (!key2.startsWith(this.prefix))
+      fail2("EIO", "listObjectsV2", path6, "key escapes the configured prefix");
+    const relative = key2.slice(this.prefix.length).replace(/\/$/, "");
+    if (!isWellFormed(key2) || key2.includes("\0") || utf8ByteLength3(key2) > 1024 || relative !== "" && relative.split("/").some((part) => !part || part === "." || part === "..")) {
+      fail2("ENOTSUP", "listObjectsV2", path6, "object key cannot be represented as a canonical filesystem path");
+    }
+  }
+  validateObject(object3, path6) {
+    const key2 = object3.Key;
+    this.validateKey(key2, path6);
+    if (object3.Size === void 0 || !Number.isSafeInteger(object3.Size) || object3.Size < 0)
+      fail2("EIO", "listObjectsV2", path6, "invalid object size");
+    if (key2.endsWith("/") && object3.Size !== 0)
+      fail2("ENOTSUP", "listObjectsV2", path6, "nonempty slash-suffixed objects cannot be treated as directories");
+  }
+  async *pages(prefix, path6, options, delimiter, maxKeys = this.pageSize) {
+    const tokens = /* @__PURE__ */ new Set();
+    let token;
+    let entries2 = 0;
+    do {
+      const page = await this.page(prefix, path6, options, delimiter, token, maxKeys);
+      entries2 += (page.Contents?.length ?? 0) + (page.CommonPrefixes?.length ?? 0);
+      if (entries2 > this.maxListEntries || tokens.size >= this.maxListEntries)
+        fail2("EFBIG", "listObjectsV2", path6, "listing exceeds maxListEntries");
+      yield page;
+      if (!page.IsTruncated)
+        return;
+      token = page.NextContinuationToken;
+      if (typeof token !== "string" || !token || tokens.has(token))
+        fail2("EIO", "listObjectsV2", path6, "missing or repeated continuation token");
+      tokens.add(token);
+    } while (true);
+  }
+  async inspect(path6, options) {
+    if (path6 === "/") {
+      const listing = await this.page(this.prefix, path6, options, void 0, void 0, 1);
+      const marker2 = this.prefix && listing.Contents?.some((object3) => object3.Key === this.prefix) ? await this.head(this.prefix, path6, options) : void 0;
+      if (marker2 && marker2.ContentLength !== 0)
+        this.unsupported("nonempty directory markers", path6);
+      return { stat: this.makeStat("directory", marker2), ...marker2 ? { metadata: marker2 } : {} };
+    }
+    const file = await this.head(this.key(path6), path6, options);
+    if (utf8ByteLength3(this.key(path6)) === 1024) {
+      return file ? { stat: this.makeStat("file", file), metadata: file } : void 0;
+    }
+    const directoryKey = this.directoryKey(path6);
+    let directory = false;
+    let hasMarker = false;
+    for await (const children of this.pages(directoryKey, path6, options, void 0, 1)) {
+      if ((children.Contents?.length ?? 0) > 0) {
+        directory = true;
+        hasMarker = children.Contents.some((object3) => object3.Key === directoryKey);
+        break;
+      }
+    }
+    const marker = hasMarker ? await this.head(directoryKey, path6, options) : void 0;
+    if (marker && marker.ContentLength !== 0)
+      this.unsupported("nonempty directory markers", path6);
+    if (file && directory)
+      this.unsupported("file/prefix collisions", path6);
+    if (file)
+      return { stat: this.makeStat("file", file), metadata: file };
+    if (directory)
+      return { stat: this.makeStat("directory", marker), ...marker ? { metadata: marker } : {} };
+    return void 0;
+  }
+  async lookup(path6, options) {
+    const ancestors = [];
+    for (let parent = posixPath.dirname(path6); path6 !== "/"; parent = posixPath.dirname(parent)) {
+      ancestors.unshift(parent);
+      if (parent === "/")
+        break;
+    }
+    for (const parent of ancestors) {
+      if (parent === "/" && this.prefix === "")
+        continue;
+      const ancestor = await this.inspect(parent, options);
+      if (!ancestor)
+        fail2("ENOENT", "stat", parent);
+      if (ancestor.stat.type !== "directory")
+        fail2("ENOTDIR", "stat", parent);
+    }
+    return this.inspect(path6, options);
+  }
+  requireDirectorySuffix(input, info) {
+    if (input.endsWith("/") && info?.stat.type === "file")
+      fail2("ENOTDIR", "stat", input);
+  }
+  async stat(input, options = {}) {
+    const path6 = this.path(input);
+    const info = await this.lookup(path6, options);
+    this.requireDirectorySuffix(input, info);
+    if (!info)
+      fail2("ENOENT", "stat", input);
+    recordS3Stat(this, path6, info.stat, info.metadata);
+    return info.stat;
+  }
+  async lstat(path6, options = {}) {
+    return this.stat(path6, options);
+  }
+  async body(output, path6, options) {
+    const limit = Math.min(this.maxReadBytes, options.maxBytes === void 0 ? this.maxReadBytes : validateLimit(options.maxBytes, "maxBytes", 0, Infinity));
+    let iterator;
+    return this.call("readFile", path6, options, async () => {
+      if (output.Body && Symbol.asyncIterator in output.Body)
+        iterator = output.Body[Symbol.asyncIterator]();
+      if (output.ContentLength !== void 0 && output.ContentLength > limit)
+        fail2("EFBIG", "readFile", path6);
+      const body = output.Body;
+      if (!body)
+        fail2("EIO", "readFile", path6, "transport omitted the response body");
+      let bytes;
+      if (body instanceof Uint8Array) {
+        if (body.byteLength > limit)
+          fail2("EFBIG", "readFile", path6);
+        bytes = new Uint8Array(body);
+      } else if (Symbol.asyncIterator in body) {
+        bytes = await collectBytes2({ [Symbol.asyncIterator]: () => iterator }, { ...limit === Infinity ? {} : { maxBytes: limit }, ...options.signal ? { signal: options.signal } : {} });
+      } else if ("transformToByteArray" in body) {
+        const converted = await body.transformToByteArray();
+        if (!(converted instanceof Uint8Array))
+          fail2("EIO", "readFile", path6, "transport body is not binary");
+        if (converted.byteLength > limit)
+          fail2("EFBIG", "readFile", path6);
+        bytes = new Uint8Array(converted);
+      } else
+        fail2("EIO", "readFile", path6, "unsupported response body");
+      this.checkAbort(options, "readFile", path6);
+      if (output.ContentLength !== void 0 && output.ContentLength !== bytes.byteLength)
+        fail2("EIO", "readFile", path6, "response body length does not match ContentLength");
+      return bytes;
+    }).catch((error) => {
+      this.dispose(iterator);
+      if (output.Body !== iterator)
+        this.dispose(output.Body, iterator === void 0);
+      throw error;
+    });
+  }
+  async get(path6, options) {
+    return this.call("getObject", path6, options, () => this.transport.getObject({ Bucket: this.bucket, Key: this.key(path6) }, this.requestOptions(options)));
+  }
+  async readFile(input, options = {}) {
+    const path6 = this.path(input);
+    if (options.maxBytes !== void 0)
+      validateLimit(options.maxBytes, "maxBytes", 0, Infinity);
+    const info = await this.stat(input, options);
+    if (info.type === "directory")
+      fail2("EISDIR", "readFile", path6);
+    if (info.size > Math.min(this.maxReadBytes, options.maxBytes ?? this.maxReadBytes))
+      fail2("EFBIG", "readFile", path6);
+    const output = this.capabilities.streamingRead ? await this.call("getObject", path6, options, () => this.transport.getObjectStream({ Bucket: this.bucket, Key: this.key(path6) }, this.requestOptions(options))) : await this.get(path6, options);
+    return this.body(output, path6, options);
+  }
+  etag(metadata, path6) {
+    if (!metadata?.ETag)
+      this.unsupported("conditional mutation without an ETag", path6);
+    return metadata.ETag;
+  }
+  async writeFile(input, data, options = {}) {
+    const path6 = this.path(input);
+    this.writable(path6, options.mode);
+    if (!(data instanceof Uint8Array))
+      fail2("EINVAL", "writeFile", path6, "data must be Uint8Array");
+    const bytes = new Uint8Array(data);
+    if (bytes.byteLength > 5e9)
+      fail2("EFBIG", "writeFile", path6, "multipart upload is not supported");
+    const flag = options.flag ?? "w";
+    if (!["w", "wx", "a", "ax"].includes(flag))
+      fail2("EINVAL", "writeFile", path6, "invalid write flag");
+    if (flag !== "w" && !this.transport.capabilities?.conditionalPut)
+      this.unsupported("conditional writes", path6);
+    const info = await this.lookup(path6, options);
+    this.requireDirectorySuffix(input, info);
+    if (info?.stat.type === "directory")
+      fail2("EISDIR", "writeFile", path6);
+    if (input.endsWith("/"))
+      fail2("EISDIR", "writeFile", input);
+    const exclusive = flag === "wx" || flag === "ax";
+    if (exclusive && info)
+      fail2("EEXIST", "writeFile", path6);
+    let body = bytes;
+    let match;
+    let metadata = this.writeMetadata(info?.metadata, options.mode);
+    if (flag === "a" && info) {
+      const current = await this.get(path6, options);
+      const previous = await this.body(current, path6, options);
+      match = this.etag(current, path6);
+      metadata = { ...current.Metadata };
+      delete metadata["virtual-bash-mtime"];
+      if (previous.length + bytes.length > this.maxReadBytes)
+        fail2("EFBIG", "appendFile", path6);
+      body = new Uint8Array(previous.length + bytes.length);
+      body.set(previous);
+      body.set(bytes, previous.length);
+    }
+    await this.call("putObject", path6, options, () => this.transport.putObject({
+      Bucket: this.bucket,
+      Key: this.key(path6),
+      Body: body,
+      ...match === void 0 ? {} : { IfMatch: match },
+      ...exclusive || flag === "a" && !info ? { IfNoneMatch: "*" } : {},
+      ...metadata === void 0 ? {} : { Metadata: metadata }
+    }, this.requestOptions(options)), exclusive ? "EEXIST" : "EAGAIN");
+  }
+  writeMetadata(previous, mode) {
+    const metadata = { ...previous?.Metadata };
+    delete metadata["virtual-bash-mtime"];
+    if (previous === void 0 && mode !== void 0)
+      metadata["virtual-bash-mode"] = String(mode);
+    return Object.keys(metadata).length === 0 ? void 0 : metadata;
+  }
+  async appendFile(path6, data, options = {}) {
+    return this.writeFile(path6, data, { ...options, flag: "a" });
+  }
+  async mkdir(input, options = {}) {
+    const path6 = this.path(input);
+    this.writable(path6, options.mode);
+    if (options.recursive && path6 !== "/") {
+      await this.mkdir(posixPath.dirname(path6), { ...options, recursive: true });
+    }
+    const info = await this.lookup(path6, options);
+    if (info) {
+      if (options.recursive && info.stat.type === "directory")
+        return;
+      fail2("EEXIST", "mkdir", path6);
+    }
+    await this.call("putObject", path6, options, () => this.transport.putObject({
+      Bucket: this.bucket,
+      Key: this.directoryKey(path6),
+      Body: new Uint8Array(),
+      ...options.mode === void 0 ? {} : { Metadata: { "virtual-bash-mode": String(options.mode) } },
+      ...this.transport.capabilities?.conditionalPut ? { IfNoneMatch: "*" } : {}
+    }, this.requestOptions(options)), "EEXIST");
+  }
+  async readdir(input, options = {}) {
+    let limit;
+    if (options.maxEntries !== void 0) {
+      this.checkAbort(options, "readdir", input);
+      limit = directoryEntryLimit(options, input);
+    }
+    const path6 = this.path(input);
+    if ((await this.stat(input, options)).type !== "directory")
+      fail2("ENOTDIR", "readdir", path6);
+    const prefix = this.directoryKey(path6);
+    const entries2 = /* @__PURE__ */ new Map();
+    const add = (name, type) => {
+      this.checkAbort(options, "readdir", path6);
+      if (!name || name.includes("/"))
+        fail2("EIO", "readdir", path6, "invalid direct child in delimited listing");
+      const existing = entries2.get(name);
+      if (existing && existing.type !== type)
+        this.unsupported("file/prefix collisions", path6);
+      if (!existing)
+        admitDirectoryEntries(entries2.size + 1, limit, path6);
+      entries2.set(name, { name, type });
+    };
+    const maxKeys = limit === void 0 ? this.pageSize : Math.min(this.pageSize, limit + 1);
+    for await (const page of this.pages(prefix, path6, options, "/", maxKeys)) {
+      for (const item of page.Contents ?? []) {
+        if (item.Key === prefix)
+          continue;
+        add(item.Key.slice(prefix.length), "file");
+      }
+      for (const item of page.CommonPrefixes ?? [])
+        add(item.Prefix.slice(prefix.length, -1), "directory");
+    }
+    return [...entries2.values()].sort((left, right) => compareKeys(left.name, right.name));
+  }
+  async tree(path6, options) {
+    const objects = /* @__PURE__ */ new Map();
+    for await (const page of this.pages(this.directoryKey(path6), path6, options)) {
+      for (const item of page.Contents ?? [])
+        objects.set(item.Key, item);
+    }
+    for (const key2 of objects.keys()) {
+      const withoutSlash = key2.replace(/\/$/, "");
+      if (key2.endsWith("/") && objects.has(withoutSlash))
+        this.unsupported("file/prefix collisions", path6);
+      let parent = posixPath.dirname(withoutSlash);
+      while (parent !== "." && parent !== "/") {
+        if (objects.has(parent))
+          this.unsupported("file/prefix collisions", path6);
+        parent = posixPath.dirname(parent);
+      }
+    }
+    return [...objects.values()];
+  }
+  async rmdir(input, options = {}) {
+    try {
+      const path6 = this.path(input);
+      this.checkAbort(options, "rmdir", input);
+      this.writable(path6);
+      if (path6 === "/")
+        fail2("EBUSY", "rmdir", input, "cannot remove the mounted root");
+      const info = await this.lookup(path6, options);
+      this.checkAbort(options, "rmdir", input);
+      if (!info)
+        fail2("ENOENT", "rmdir", input);
+      if (info.stat.type !== "directory")
+        fail2("ENOTDIR", "rmdir", input);
+      const prefix = this.directoryKey(path6);
+      let markerObserved = false;
+      for await (const page of this.pages(prefix, path6, options, "/", Math.max(2, this.pageSize))) {
+        this.checkAbort(options, "rmdir", input);
+        if (page.Contents?.some((item) => item.Key !== prefix) || page.CommonPrefixes?.length) {
+          fail2("ENOTEMPTY", "rmdir", input);
+        }
+        if (page.IsTruncated === void 0)
+          fail2("EIO", "rmdir", input, "listing did not confirm completeness");
+        if (page.Contents?.some((item) => item.Key === prefix))
+          markerObserved = true;
+      }
+      this.checkAbort(options, "rmdir", input);
+      if (!info.metadata)
+        fail2("ENOTSUP", "rmdir", input, "snapshot removal requires an explicit directory marker");
+      if (!markerObserved)
+        fail2("ENOENT", "rmdir", input, "directory marker disappeared during inspection");
+      await this.call("deleteObject", path6, options, () => this.transport.deleteObject({ Bucket: this.bucket, Key: prefix }, this.requestOptions(options)));
+    } catch (error) {
+      if (isFsError(error) && (error.syscall !== "rmdir" || error.path !== input)) {
+        throw new FsError(error.code, { syscall: "rmdir", path: input, cause: error });
+      }
+      throw error;
+    }
+  }
+  async rm(input, options = {}) {
+    options = { ...options };
+    const budget = { requests: 0, entries: 0 };
+    this.removalBudgets.set(options, budget);
+    const path6 = this.path(input);
+    this.writable(path6);
+    if (path6 === "/")
+      fail2("EBUSY", "rm", path6, "cannot remove the mounted root");
+    let info;
+    try {
+      info = await this.lookup(path6, options);
+    } catch (error) {
+      if (options.force && isFsError(error, "ENOENT") && serviceCode(error.cause) !== "NoSuchBucket")
+        return;
+      throw error;
+    }
+    this.requireDirectorySuffix(input, info);
+    if (!info) {
+      if (options.force)
+        return;
+      fail2("ENOENT", "rm", path6);
+    }
+    let objects;
+    if (info.stat.type === "directory" && !options.recursive) {
+      const prefix = this.directoryKey(path6);
+      objects = [];
+      for await (const page of this.pages(prefix, path6, options, void 0, 2)) {
+        if (page.Contents?.some((item) => item.Key !== prefix))
+          fail2("ENOTEMPTY", "rm", path6);
+        if (page.Contents?.length)
+          objects = [{ Key: prefix }];
+      }
+    } else {
+      objects = info.stat.type === "directory" ? await this.tree(path6, options) : [{ Key: this.key(path6) }];
+    }
+    if (objects.length > this.removalLimits.maxDeleteObjects || budget.requests + objects.length > this.removalLimits.maxRequests) {
+      fail2("EFBIG", "rm", path6, "S3 removal delete or request budget exceeded; use bounded batches");
+    }
+    for (const item of objects) {
+      await this.call("deleteObject", path6, options, () => this.transport.deleteObject({ Bucket: this.bucket, Key: item.Key }, this.requestOptions(options)));
+    }
+  }
+  async copy(sourceKey, destinationKey, source, metadata, options, destination) {
+    if (metadata.ContentLength === void 0 || metadata.ContentLength > 5e9)
+      this.unsupported("multipart copy", source);
+    const etag = this.etag(metadata, source);
+    const result = await this.call("copyObject", source, options, () => this.transport.copyObject({
+      Bucket: this.bucket,
+      Key: destinationKey,
+      CopySource: encodeCopySource(this.bucket, sourceKey),
+      CopySourceIfMatch: etag,
+      MetadataDirective: "COPY",
+      ...options.exclusive ? { IfNoneMatch: "*" } : {},
+      ...destination === void 0 ? {} : destination === null ? { IfNoneMatch: "*" } : { IfMatch: this.etag(destination, source) }
+    }, this.requestOptions(options)));
+    if (!result.CopyObjectResult?.ETag)
+      fail2("EIO", "copyObject", source, "transport did not confirm a completed CopyObject result");
+  }
+  async copyFile(sourceInput, destinationInput, options = {}) {
+    const source = this.path(sourceInput);
+    const destination = this.path(destinationInput);
+    this.writable(destination);
+    if (options.exclusive && !this.transport.capabilities?.conditionalCopy)
+      this.unsupported("exclusive server-side copy", destination);
+    const origin = await this.lookup(source, options);
+    this.requireDirectorySuffix(sourceInput, origin);
+    if (!origin)
+      fail2("ENOENT", "copyFile", source);
+    if (origin.stat.type === "directory")
+      fail2("EISDIR", "copyFile", source);
+    const target = await this.lookup(destination, options);
+    this.requireDirectorySuffix(destinationInput, target);
+    if (target?.stat.type === "directory" || destinationInput.endsWith("/"))
+      fail2("EISDIR", "copyFile", destination);
+    if (target && options.exclusive)
+      fail2("EEXIST", "copyFile", destination);
+    if (source === destination)
+      return;
+    try {
+      await this.copy(this.key(source), this.key(destination), source, origin.metadata, options);
+    } catch (error) {
+      if (!options.exclusive || !isFsError(error, "EAGAIN"))
+        throw error;
+      const status = error.cause?.$metadata?.httpStatusCode;
+      if (serviceCode(error.cause) !== "PreconditionFailed" && status !== 412)
+        throw error;
+      let destinationExists = false;
+      try {
+        const currentSource = await this.head(this.key(source), source, options);
+        if (currentSource?.ETag === origin.metadata?.ETag) {
+          destinationExists = await this.head(this.key(destination), destination, options) !== void 0;
+        }
+      } catch (diagnosticError) {
+        if (isFsError(diagnosticError, "ECANCELED"))
+          throw diagnosticError;
+      }
+      if (destinationExists) {
+        throw new FsError("EEXIST", { syscall: "copyFile", path: source, dest: destination, cause: error });
+      }
+      throw error;
+    }
+  }
+  async rename(sourceInput, destinationInput, options = {}) {
+    if (options.noReplace) {
+      options.signal?.throwIfAborted();
+      this.unsupported("atomic no-replace rename", sourceInput);
+    }
+    const source = this.path(sourceInput);
+    const destination = this.path(destinationInput);
+    this.writable(destination);
+    if (!this.allowRename)
+      this.unsupported("atomic rename; explicitly enable allowNonAtomicRename for copy/delete semantics", source);
+    if (!this.transport.capabilities?.conditionalDelete)
+      this.unsupported("rename without conditional delete", source);
+    const conditionalCopy = this.transport.capabilities?.conditionalCopy === true;
+    if (!conditionalCopy && this.transport.capabilities?.conditionalPut !== true) {
+      this.unsupported("rename requires conditional destination copy or conditional PUT, plus conditional delete", source);
+    }
+    const streamFallback = this.capabilities.streamingRead && this.capabilities.streamingWrite;
+    if (source === "/" || destination === "/")
+      fail2("EBUSY", "rename", source);
+    const origin = await this.lookup(source, options);
+    this.requireDirectorySuffix(sourceInput, origin);
+    if (!origin)
+      fail2("ENOENT", "rename", source);
+    if (source === destination) {
+      this.requireDirectorySuffix(destinationInput, origin);
+      return;
+    }
+    if (destination.startsWith(`${source}/`))
+      fail2("EINVAL", "rename", destination, "cannot move a path into itself");
+    const target = await this.lookup(destination, options);
+    this.requireDirectorySuffix(destinationInput, target);
+    if (destinationInput.endsWith("/") && origin.stat.type !== "directory")
+      fail2("ENOTDIR", "rename", destination);
+    if (target && target.stat.type !== origin.stat.type)
+      fail2(target.stat.type === "directory" ? "EISDIR" : "ENOTDIR", "rename", destination);
+    if (target?.stat.type === "directory" && (await this.readdir(destination, options)).length > 0)
+      fail2("ENOTEMPTY", "rename", destination);
+    if (target?.metadata)
+      this.etag(target.metadata, destination);
+    const objects = origin.stat.type === "directory" ? await this.tree(source, options) : [{
+      Key: this.key(source),
+      Size: origin.stat.size,
+      ETag: origin.metadata?.ETag
+    }];
+    for (const object3 of objects) {
+      this.etag({ ETag: object3.ETag }, source);
+      if (object3.Size === void 0 || object3.Size > 5e9)
+        this.unsupported("multipart copy", source);
+      if (!conditionalCopy && object3.Size > (streamFallback ? this.maxStreamBytes : this.maxReadBytes)) {
+        fail2("EFBIG", "rename", source, "conditional PUT fallback exceeds its configured transfer or buffered read limit");
+      }
+      if (utf8ByteLength3(this.key(destination) + object3.Key.slice(this.key(source).length)) > 1024)
+        fail2("ENAMETOOLONG", "rename", destination);
+    }
+    const copied = [];
+    const deleted = [];
+    let phase = "copy";
+    try {
+      for (const object3 of objects) {
+        const destinationKey = this.key(destination) + object3.Key.slice(this.key(source).length);
+        const destinationMetadata = origin.stat.type === "file" || object3.Key === this.directoryKey(source) ? target?.metadata ?? null : null;
+        const metadata = { ContentLength: object3.Size, ETag: object3.ETag };
+        if (conditionalCopy)
+          await this.copy(object3.Key, destinationKey, source, metadata, options, destinationMetadata);
+        else
+          await this.copyWithPut(object3.Key, destinationKey, source, metadata, destinationMetadata, options, streamFallback);
+        copied.push(destinationKey);
+      }
+      phase = "delete";
+      for (const object3 of objects) {
+        await this.call("deleteObject", source, options, () => this.transport.deleteObject({
+          Bucket: this.bucket,
+          Key: object3.Key,
+          IfMatch: object3.ETag
+        }, this.requestOptions(options)));
+        deleted.push(object3.Key);
+      }
+    } catch (error) {
+      throw new S3RenameError(source, destination, phase, copied, deleted, translate(error, "rename", source));
+    }
+  }
+  async copyWithPut(sourceKey, destinationKey, source, expected, destination, options, streaming) {
+    const etag = this.etag(expected, source);
+    const condition = destination === null ? { IfNoneMatch: "*" } : { IfMatch: this.etag(destination, destinationKey) };
+    const controller = new AbortController();
+    const signalScope = options.signal ? composeAbortSignals([options.signal, controller.signal]) : void 0;
+    const signal = signalScope?.signal ?? controller.signal;
+    const operationOptions = { signal };
+    let output;
+    let upload;
+    let reading = false;
+    try {
+      output = await this.call("getObject", source, operationOptions, () => streaming ? this.transport.getObjectStream({ Bucket: this.bucket, Key: sourceKey, IfMatch: etag }, { abortSignal: signal }) : this.transport.getObject({ Bucket: this.bucket, Key: sourceKey }, { abortSignal: signal }));
+      if (this.etag(output, source) !== etag)
+        fail2("EAGAIN", "rename", source, "source changed before conditional PUT copy");
+      if (output.ContentLength !== void 0 && output.ContentLength !== expected.ContentLength) {
+        fail2("EIO", "rename", source, "source response length differs from the enumerated object");
+      }
+      const input = {
+        Bucket: this.bucket,
+        Key: destinationKey,
+        ...condition,
+        ...output.Metadata === void 0 ? {} : { Metadata: { ...output.Metadata } }
+      };
+      if (!streaming) {
+        const body2 = await this.body(output, source, operationOptions);
+        if (body2.length !== expected.ContentLength)
+          fail2("EIO", "rename", source, "source body length differs from the enumerated object");
+        await this.call("putObject", source, operationOptions, () => this.transport.putObject({ ...input, Body: body2 }, { abortSignal: signal }));
+        return;
+      }
+      const body = output.Body;
+      if (!body || !(Symbol.asyncIterator in body))
+        fail2("EIO", "rename", source, "streaming transport did not return an async binary body");
+      let finished = false;
+      upload = (async function* () {
+        let count = 0;
+        reading = true;
+        for await (const chunk of readBytes(body, signal)) {
+          if (chunk.length > expected.ContentLength - count)
+            fail2("EIO", "rename", source, "source body exceeds its enumerated length");
+          count += chunk.length;
+          for (let offset = 0; offset < chunk.length; offset += 64 * 1024) {
+            signal.throwIfAborted();
+            yield new Uint8Array(chunk.subarray(offset, offset + 64 * 1024));
+          }
+        }
+        if (count !== expected.ContentLength)
+          fail2("EIO", "rename", source, "incomplete source body");
+        finished = true;
+      })();
+      await this.call("putObject", source, operationOptions, () => this.transport.putObjectStream({ ...input, Body: upload }, { abortSignal: signal }));
+      if (!finished)
+        fail2("EIO", "rename", source, "transport completed without consuming the conditional copy body");
+    } finally {
+      controller.abort();
+      signalScope?.dispose();
+      this.dispose(upload);
+      this.dispose(output?.Body, !reading);
+    }
+  }
+  async realpath(input, options = {}) {
+    await this.stat(input, options);
+    return this.path(input);
+  }
+  async access(path6, mode = 0, options = {}) {
+    if (!Number.isInteger(mode) || mode < 0 || mode > 7)
+      fail2("EINVAL", "access", path6);
+    const info = await this.stat(path6, options);
+    if ((mode & 2) !== 0 && this.capabilities.readOnly)
+      fail2("EROFS", "access", path6);
+    if ((mode & 1) !== 0 && info.type !== "directory")
+      fail2("EACCES", "access", path6);
+  }
+  async readlink(path6) {
+    return this.unsupported("readlink", path6);
+  }
+  async symlink(_target, path6) {
+    this.unsupported("symlink", path6);
+  }
+  async link(_existingPath, path6) {
+    this.unsupported("link", path6);
+  }
+  async chmod(path6, _mode) {
+    this.unsupported("chmod", path6);
+  }
+  async utimes(input, atimeMs, mtimeMs, options = {}) {
+    const path6 = this.path(input);
+    this.writable(path6);
+    if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs))
+      fail2("EINVAL", "utimes", path6);
+    const info = await this.lookup(path6, options);
+    this.requireDirectorySuffix(input, info);
+    if (!info)
+      fail2("ENOENT", "utimes", path6);
+    if (!this.capabilities.timestamps)
+      this.unsupported("conditional metadata mutation", path6);
+    const key2 = info.stat.type === "directory" ? this.directoryKey(path6) : this.key(path6);
+    if (!key2)
+      this.unsupported("timestamps on an unprefixed bucket root", path6);
+    const metadata = {
+      ...info.metadata?.Metadata,
+      "virtual-bash-atime": String(atimeMs),
+      "virtual-bash-mtime": String(mtimeMs)
+    };
+    if (!info.metadata) {
+      if (!this.transport.capabilities?.conditionalPut)
+        this.unsupported("conditional directory marker creation", path6);
+      await this.call("utimes", path6, options, () => this.transport.putObject({
+        Bucket: this.bucket,
+        Key: key2,
+        Body: new Uint8Array(),
+        Metadata: metadata,
+        IfNoneMatch: "*"
+      }, this.requestOptions(options)));
+      return;
+    }
+    if (!this.transport.capabilities?.conditionalCopy) {
+      const current = await this.call("getObject", path6, options, () => this.transport.getObject({
+        Bucket: this.bucket,
+        Key: key2
+      }, this.requestOptions(options)));
+      const body = await this.body(current, path6, options);
+      await this.call("utimes", path6, options, () => this.transport.putObject({
+        Bucket: this.bucket,
+        Key: key2,
+        Body: body,
+        IfMatch: this.etag(current, path6),
+        Metadata: { ...current.Metadata, "virtual-bash-atime": String(atimeMs), "virtual-bash-mtime": String(mtimeMs) }
+      }, this.requestOptions(options)));
+      return;
+    }
+    if (info.stat.size > 5e9)
+      this.unsupported("multipart metadata copy", path6);
+    const etag = this.etag(info.metadata, path6);
+    const result = await this.call("utimes", path6, options, () => this.transport.copyObject({
+      Bucket: this.bucket,
+      Key: key2,
+      CopySource: encodeCopySource(this.bucket, key2),
+      CopySourceIfMatch: etag,
+      IfMatch: etag,
+      MetadataDirective: "REPLACE",
+      Metadata: metadata
+    }, this.requestOptions(options)));
+    if (!result.CopyObjectResult?.ETag)
+      fail2("EIO", "utimes", path6, "transport did not confirm a completed metadata copy");
+  }
+  async truncate(input, length = 0, options = {}) {
+    const path6 = this.path(input);
+    this.writable(path6);
+    validateLimit(length, "length", 0);
+    const info = await this.lookup(path6, options);
+    this.requireDirectorySuffix(input, info);
+    if (!info)
+      fail2("ENOENT", "truncate", path6);
+    if (info.stat.type === "directory")
+      fail2("EISDIR", "truncate", path6);
+    if (!this.transport.capabilities?.conditionalPut)
+      this.unsupported("conditional truncate", path6);
+    if (length > this.maxReadBytes)
+      fail2("EFBIG", "truncate", path6);
+    let current = info.metadata;
+    const body = new Uint8Array(length);
+    if (length !== 0 && info.stat.size !== 0) {
+      if (this.readStream) {
+        const previous = await this.call("truncate", path6, options, () => collectBytes2(this.readStream(input, { ...options, endExclusive: Math.min(length, info.stat.size) }), { ...options, maxBytes: length }));
+        body.set(previous);
+      } else {
+        const output = await this.get(path6, options);
+        const previous = await this.body(output, path6, options);
+        current = output;
+        body.set(previous.subarray(0, length));
+      }
+    }
+    const metadata = { ...current.Metadata };
+    delete metadata["virtual-bash-mtime"];
+    await this.call("truncate", path6, options, () => this.transport.putObject({
+      Bucket: this.bucket,
+      Key: this.key(path6),
+      Body: body,
+      IfMatch: this.etag(current, path6),
+      Metadata: metadata
+    }, this.requestOptions(options)));
+  }
+  async *streamRead(input, options = {}) {
+    const path6 = this.path(input);
+    const start = validateLimit(options.start ?? 0, "start", 0);
+    const end = options.endExclusive === void 0 ? void 0 : validateLimit(options.endExclusive, "endExclusive", start);
+    const chunkSize = validateLimit(options.chunkSize ?? 64 * 1024, "chunkSize", 1);
+    const info = await this.lookup(path6, options);
+    this.requireDirectorySuffix(input, info);
+    if (!info)
+      fail2("ENOENT", "readStream", path6);
+    if (info.stat.type === "directory")
+      fail2("EISDIR", "readStream", path6);
+    const stop = Math.min(end ?? info.stat.size, info.stat.size);
+    const expected = Math.max(0, stop - start);
+    if (expected > this.maxStreamBytes)
+      fail2("EFBIG", "readStream", path6);
+    if (expected === 0 && info.stat.size !== 0)
+      return;
+    let count = 0;
+    let finished = false;
+    const controller = new AbortController();
+    const signalScope = options.signal ? composeAbortSignals([options.signal, controller.signal]) : void 0;
+    const signal = signalScope?.signal ?? controller.signal;
+    let output;
+    let iterator;
+    try {
+      output = await this.call("getObject", path6, options, () => this.transport.getObjectStream({
+        Bucket: this.bucket,
+        Key: this.key(path6),
+        IfMatch: this.etag(info.metadata, path6),
+        ...expected === 0 || start === 0 && stop === info.stat.size ? {} : { Range: `bytes=${start}-${stop - 1}` }
+      }, { abortSignal: signal }));
+      if (output.ETag !== void 0 && output.ETag !== info.metadata?.ETag)
+        fail2("EIO", "readStream", path6, "response ETag differs from requested snapshot");
+      if (output.ContentLength !== void 0 && output.ContentLength !== expected)
+        fail2("EIO", "readStream", path6, "response length differs from requested snapshot");
+      iterator = readBytes(output.Body, signal)[Symbol.asyncIterator]();
+      while (true) {
+        const result = await iterator.next();
+        if (result.done)
+          break;
+        const chunk = result.value;
+        if (chunk.length > expected - count)
+          fail2("EIO", "readStream", path6, "response exceeds requested length");
+        count += chunk.length;
+        for (let offset = 0; offset < chunk.length; offset += chunkSize) {
+          this.checkAbort(options, "readStream", path6);
+          yield new Uint8Array(chunk.subarray(offset, offset + chunkSize));
+        }
+      }
+      if (count !== expected)
+        fail2("EIO", "readStream", path6, "incomplete response body");
+      finished = true;
+    } catch (error) {
+      this.checkAbort(options, "readStream", path6);
+      throw translate(error, "readStream", path6);
+    } finally {
+      controller.abort();
+      signalScope?.dispose();
+      if (!finished && output) {
+        this.dispose(iterator);
+        this.dispose(output.Body, iterator === void 0);
+      }
+    }
+  }
+  dispose(body, returnIterator = true) {
+    const disposable = body;
+    try {
+      const result = typeof disposable?.destroy === "function" ? disposable.destroy() : typeof disposable?.cancel === "function" ? disposable.cancel() : returnIterator ? disposable?.return?.() : void 0;
+      void Promise.resolve(result).catch(() => {
+      });
+    } catch (ignoredError) {
+      void ignoredError;
+    }
+  }
+  async streamWrite(input, source, options = {}) {
+    const path6 = this.path(input);
+    this.writable(path6, options.mode);
+    const flag = options.flag ?? "w";
+    if (!["w", "wx", "a", "ax"].includes(flag))
+      fail2("EINVAL", "writeStream", path6);
+    if (flag !== "w" && !this.transport.capabilities?.conditionalPut)
+      this.unsupported("conditional writes", path6);
+    const info = await this.lookup(path6, options);
+    this.requireDirectorySuffix(input, info);
+    if (info?.stat.type === "directory" || input.endsWith("/"))
+      fail2("EISDIR", "writeStream", path6);
+    const exclusive = flag === "wx" || flag === "ax";
+    if (exclusive && info)
+      fail2("EEXIST", "writeStream", path6);
+    if (flag === "a") {
+      const current = info ? await this.get(path6, options) : void 0;
+      const previous = current ? await this.body(current, path6, options) : new Uint8Array();
+      const limit = Math.min(this.maxReadBytes, this.maxStreamBytes);
+      if (previous.length > limit)
+        fail2("EFBIG", "writeStream", path6);
+      const bytes = await this.call("writeStream", path6, options, () => collectBytes2(source, { ...limit === Infinity ? {} : { maxBytes: limit - previous.length }, ...options }));
+      const body2 = new Uint8Array(previous.length + bytes.length);
+      body2.set(previous);
+      body2.set(bytes, previous.length);
+      const metadata = this.writeMetadata(current, options.mode);
+      await this.call("putObject", path6, options, () => this.transport.putObject({
+        Bucket: this.bucket,
+        Key: this.key(path6),
+        Body: body2,
+        ...current ? { IfMatch: this.etag(current, path6) } : { IfNoneMatch: "*" },
+        ...metadata ? { Metadata: metadata } : {}
+      }, this.requestOptions(options)));
+      return;
+    }
+    const controller = new AbortController();
+    const signalScope = options.signal ? composeAbortSignals([options.signal, controller.signal]) : void 0;
+    const signal = signalScope?.signal ?? controller.signal;
+    let finished = false;
+    const body = (async function* () {
+      let total = 0;
+      for await (const chunk of readBytes(source, signal)) {
+        if (chunk.length > this.maxStreamBytes - total)
+          fail2("EFBIG", "writeStream", path6);
+        total += chunk.length;
+        for (let offset = 0; offset < chunk.length; offset += 64 * 1024) {
+          this.checkAbort({ signal }, "writeStream", path6);
+          yield new Uint8Array(chunk.subarray(offset, offset + 64 * 1024));
+        }
+      }
+      finished = true;
+    }).call(this);
+    try {
+      const metadata = this.writeMetadata(info?.metadata, options.mode);
+      await this.call("putObject", path6, options, () => this.transport.putObjectStream({
+        Bucket: this.bucket,
+        Key: this.key(path6),
+        Body: body,
+        ...exclusive ? { IfNoneMatch: "*" } : {},
+        ...metadata === void 0 ? {} : { Metadata: metadata }
+      }, { abortSignal: signal }), exclusive ? "EEXIST" : "EAGAIN");
+      if (!finished)
+        fail2("EIO", "writeStream", path6, "transport completed without consuming the request body");
+    } finally {
+      controller.abort();
+      signalScope?.dispose();
+      this.dispose(body);
+    }
+  }
+};
+var s3Comparison = S3FileSystem.prototype.compareEntry;
+
 // src/management.ts
 import { commandRuntimeIdentity as commandRuntimeIdentity2, collectBytes as collectBytes3, toByteSource, createOutputOperation as createOutputOperation2 } from "@poe-platform/safe-bash/contracts";