@poe-platform/safe-bash 0.1.799 → 0.1.801

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);
@@ -1842,7 +1921,7 @@ async function requestTokens(input) {
   if (method === "client_secret_basic") {
     const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
     const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
-    headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+    headers.set("Authorization", `Basic ${btoa(`${encoded}:${encodedSecret}`)}`);
   } else {
     body.set("client_id", input.clientId);
     if (method === "client_secret_post")
@@ -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;
@@ -2032,10 +2111,10 @@ function createDefaultOAuthClientProvider(options) {
   if (resourceIdentity !== void 0 && selectedSessionStore !== void 0)
     throw new Error("OAuth resourceIdentity requires native-owned persistence; custom stores own their resource trust policy");
   const now = () => {
-    const timestamp = clock();
-    if (!Number.isSafeInteger(timestamp) || Math.abs(timestamp) > MAX_JS_DATE_MS3)
+    const timestamp2 = clock();
+    if (!Number.isSafeInteger(timestamp2) || Math.abs(timestamp2) > MAX_JS_DATE_MS3)
       throw new Error("OAuth clock must return valid epoch milliseconds");
-    return timestamp;
+    return timestamp2;
   };
   const registeredClients = /* @__PURE__ */ new Map();
   const resourceStores = resourceIdentity === void 0 ? void 0 : createResourceBoundOAuthStores(authStore ?? {}, persistenceNamespace, resourceIdentity);
@@ -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) {
@@ -2822,6 +2901,155 @@ function shouldReRegisterStoredDynamicClient(error, client, alreadyAttempted) {
   return client.registrationOwnership !== "caller";
 }
 
+// ../mcp-oauth/dist/client/resumable.js
+var responseParameters = ["code", "state", "iss", "error", "error_description", "error_uri"];
+function httpsUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" || url.username || url.password || url.href.includes("#"))
+    throw new Error();
+  return url;
+}
+function base64url(bytes) {
+  return btoa(String.fromCharCode(...bytes)).split("+").join("-").split("/").join("_").split("=").join("");
+}
+function timestamp(now) {
+  const value = now();
+  if (!Number.isSafeInteger(value) || value < 0 || value > 864e13 - 6e5)
+    throw new Error();
+  return value;
+}
+async function beginRemoteMcpAuthorization(options) {
+  try {
+    const { store, signal, discover } = options;
+    const now = options.now?.bind(options) ?? Date.now;
+    const resource = httpsUrl(options.resource).href;
+    const redirect = httpsUrl(options.redirectUri);
+    if (responseParameters.some((key2) => redirect.searchParams.has(key2)))
+      throw new Error();
+    const client = structuredClone(options.client);
+    if (typeof client.clientId !== "string" || !client.clientId.trim())
+      throw new Error();
+    const method = normalizeOAuthTokenEndpointAuthMethod(client.tokenEndpointAuthMethod) ?? (client.clientSecret === void 0 ? "none" : "client_secret_post");
+    if (client.clientSecret !== void 0 && (typeof client.clientSecret !== "string" || !client.clientSecret.trim()))
+      throw new Error();
+    if (method !== "none" && client.clientSecret === void 0)
+      throw new Error();
+    if (client.registration !== void 0 && (client.registration.client_id !== client.clientId || client.registration.client_secret != null && client.registration.client_secret !== client.clientSecret || client.registration.token_endpoint_auth_method != null && client.registration.token_endpoint_auth_method !== method))
+      throw new Error();
+    client.tokenEndpointAuthMethod = method;
+    if (client.requestedRedirectUri !== void 0 && client.requestedRedirectUri !== redirect.href)
+      throw new Error();
+    if (client.registration?.redirect_uris != null && !client.registration.redirect_uris.includes(redirect.href))
+      throw new Error();
+    const scope = normalizeOAuthScope(options.scope);
+    const ttl = options.ttlMs ?? 6e5;
+    if (!Number.isSafeInteger(ttl) || ttl < 1 || ttl > 6e5)
+      throw new Error();
+    signal?.throwIfAborted();
+    const metadata = structuredClone(await discover(resource, signal));
+    signal?.throwIfAborted();
+    const server = metadata.authorizationServerMetadata;
+    if (httpsUrl(metadata.resource).href !== resource || httpsUrl(metadata.resourceMetadata.resource).href !== resource || server.issuer !== metadata.authorizationServer || !metadata.resourceMetadata.authorization_servers.includes(server.issuer) || !server.response_types_supported.includes("code") || !server.code_challenge_methods_supported.includes("S256"))
+      throw new Error();
+    httpsUrl(server.issuer);
+    httpsUrl(server.token_endpoint);
+    const authorization = httpsUrl(server.authorization_endpoint);
+    const state = base64url(crypto.getRandomValues(new Uint8Array(32)));
+    const codeVerifier = base64url(crypto.getRandomValues(new Uint8Array(32)));
+    const challenge = base64url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier))));
+    const expiresAt = timestamp(now) + ttl;
+    const session = {
+      resource,
+      authorizationServer: server.issuer,
+      client: { ...client, registrationOwnership: "caller", requestedRedirectUri: redirect.href },
+      ...scope === void 0 ? {} : { requestedScope: scope },
+      discovery: { resourceMetadataUrl: metadata.resourceMetadataUrl, resourceMetadata: metadata.resourceMetadata, authorizationServerMetadata: server }
+    };
+    for (const [key2, value] of Object.entries({
+      response_type: "code",
+      client_id: client.clientId,
+      redirect_uri: redirect.href,
+      resource,
+      state,
+      code_challenge: challenge,
+      code_challenge_method: "S256"
+    }))
+      authorization.searchParams.set(key2, value);
+    authorization.searchParams.delete("scope");
+    if (scope !== void 0)
+      authorization.searchParams.set("scope", scope);
+    signal?.throwIfAborted();
+    await store.create({
+      state,
+      expiresAt,
+      redirectUri: redirect.href,
+      codeVerifier,
+      requireIssuer: server.authorization_response_iss_parameter_supported === true,
+      session
+    });
+    signal?.throwIfAborted();
+    return { authorizationUrl: authorization.href, expiresAt };
+  } catch {
+    throw new Error("Unable to begin MCP authorization");
+  }
+}
+async function completeRemoteMcpAuthorization(options) {
+  try {
+    const { store, fetch: fetch2, signal } = options;
+    const now = options.now?.bind(options) ?? Date.now;
+    const callback = httpsUrl(options.callbackUrl);
+    for (const key2 of responseParameters)
+      if (callback.searchParams.getAll(key2).length > 1)
+        throw new Error();
+    const state = callback.searchParams.get("state");
+    if (!state || state.length > 256)
+      throw new Error();
+    signal?.throwIfAborted();
+    const stored = await store.consume(state);
+    if (stored === null)
+      throw new Error();
+    const transaction = structuredClone(stored);
+    if (transaction.state !== state || !Number.isSafeInteger(transaction.expiresAt) || transaction.expiresAt <= timestamp(now))
+      throw new Error();
+    const expected = httpsUrl(transaction.redirectUri);
+    const issuer = callback.searchParams.get("iss");
+    if (transaction.requireIssuer && issuer === null || issuer !== null && issuer !== transaction.session.authorizationServer)
+      throw new Error();
+    const code = callback.searchParams.get("code");
+    if (!code || callback.searchParams.has("error"))
+      throw new Error();
+    for (const key2 of responseParameters)
+      callback.searchParams.delete(key2);
+    const actualPairs = [...callback.searchParams].sort(), expectedPairs = [...expected.searchParams].sort();
+    if (callback.origin !== expected.origin || callback.pathname !== expected.pathname || JSON.stringify(actualPairs) !== JSON.stringify(expectedPairs))
+      throw new Error();
+    const session = structuredClone(transaction.session);
+    const tokenEndpoint = httpsUrl(String(session.discovery.authorizationServerMetadata.token_endpoint)).href;
+    signal?.throwIfAborted();
+    session.tokens = await exchangeAuthorizationCode({
+      tokenEndpoint,
+      clientId: session.client.clientId,
+      clientSecret: session.client.clientSecret,
+      tokenEndpointAuthMethod: session.client.tokenEndpointAuthMethod,
+      code,
+      codeVerifier: transaction.codeVerifier,
+      redirectUri: transaction.redirectUri,
+      resource: session.resource,
+      fetch: fetch2,
+      signal,
+      now
+    });
+    if (session.tokens.scope === void 0 && session.requestedScope !== void 0)
+      session.tokens.scope = session.requestedScope;
+    signal?.throwIfAborted();
+    if (transaction.expiresAt <= timestamp(now) || !await store.commit(transaction, session))
+      throw new Error();
+    return { resource: session.resource };
+  } catch {
+    throw new Error("Unable to complete MCP authorization");
+  }
+}
+
 // src/oauth-policy.ts
 function snapshotOAuthBindingOptions(oauth) {
   return {
@@ -2841,6 +3069,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,
@@ -2852,8 +3081,8 @@ function snapshotOAuthBrowserOptions(browser) {
 // ../tiny-mcp-client/dist/index.js
 import { PassThrough } from "node:stream";
 import http2 from "node:http";
-import crypto5 from "node:crypto";
 import crypto22 from "node:crypto";
+import crypto32 from "node:crypto";
 import path42 from "node:path";
 import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes2, randomUUID as randomUUID22, scrypt as scrypt2 } from "node:crypto";
 import { promises as fs2 } from "node:fs";
@@ -2868,7 +3097,7 @@ import { homedir as homedir22 } from "node:os";
 import path32 from "node:path";
 import { isIP as isIP2 } from "node:net";
 import { URL as URL22 } from "node:url";
-import crypto32 from "node:crypto";
+import crypto42 from "node:crypto";
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res, err) => function __init() {
@@ -6221,9 +6450,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;
@@ -6393,7 +6622,7 @@ function copyBoundedOAuthJson2(value, message) {
 function createAuthorizationState2(input) {
   const payload = {
     v: 1,
-    n: crypto5.randomBytes(16).toString("base64url"),
+    n: crypto22.randomBytes(16).toString("base64url"),
     i: input.issuer,
     r: input.requireIssuer
   };
@@ -6452,6 +6681,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 +6696,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 +6763,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 +7091,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");
     }
@@ -7572,7 +7880,7 @@ function snapshotPersistenceOptions2(options) {
 }
 function createNamedSecretStore2(key2, options, defaults, namespace) {
   options = snapshotOAuthPersistenceOptions2(options);
-  const hash = crypto22.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
+  const hash = crypto32.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
   const configuredFilePath = options.fileStore?.filePath;
   const parsedFilePath = configuredFilePath === void 0 ? null : path42.parse(configuredFilePath);
   const fileStore = {
@@ -7651,7 +7959,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);
@@ -7874,10 +8182,10 @@ async function fetchMcpResponse2(fetchImplementation, input, init = {}) {
   });
 }
 function generateCodeVerifier2() {
-  return crypto32.randomBytes(32).toString("base64url");
+  return crypto42.randomBytes(32).toString("base64url");
 }
 function generateCodeChallenge2(verifier) {
-  return crypto32.createHash("sha256").update(verifier).digest("base64url");
+  return crypto42.createHash("sha256").update(verifier).digest("base64url");
 }
 async function readBoundedResponseText2(response, maxBytes, readers, signal) {
   if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 1))
@@ -8006,7 +8314,7 @@ async function requestTokens2(input) {
   if (method === "client_secret_basic") {
     const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
     const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
-    headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+    headers.set("Authorization", `Basic ${btoa(`${encoded}:${encodedSecret}`)}`);
   } else {
     body.set("client_id", input.clientId);
     if (method === "client_secret_post")
@@ -8055,7 +8363,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 +8492,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;
@@ -8198,10 +8506,10 @@ function createDefaultOAuthClientProvider2(options) {
   if (resourceIdentity !== void 0 && selectedSessionStore !== void 0)
     throw new Error("OAuth resourceIdentity requires native-owned persistence; custom stores own their resource trust policy");
   const now = () => {
-    const timestamp = clock();
-    if (!Number.isSafeInteger(timestamp) || Math.abs(timestamp) > MAX_JS_DATE_MS32)
+    const timestamp2 = clock();
+    if (!Number.isSafeInteger(timestamp2) || Math.abs(timestamp2) > MAX_JS_DATE_MS32)
       throw new Error("OAuth clock must return valid epoch milliseconds");
-    return timestamp;
+    return timestamp2;
   };
   const registeredClients = /* @__PURE__ */ new Map();
   const resourceStores = resourceIdentity === void 0 ? void 0 : createResourceBoundOAuthStores2(authStore ?? {}, persistenceNamespace, resourceIdentity);
@@ -8781,7 +9089,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 +9098,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 +14361,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 +14401,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 +14525,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)
@@ -14641,16 +15012,31 @@ async function openFileDescriptor(path6, options, capabilities, acquire) {
 }
 
 // ../safe-fs/dist/contracts/virtual-path.js
-var MAX_PATH_BYTES = 65536;
-var MAX_PATH_COMPONENTS = 2048;
-function validatePath(path6, maxComponents = MAX_PATH_COMPONENTS) {
+function pathByteLength(path6) {
+  let bytes = 0;
+  for (const point of path6) {
+    const code = point.codePointAt(0);
+    bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function validatePath(path6, limits = {}) {
+  const maxBytes = typeof limits === "number" ? Infinity : limits.maxPathBytes ?? Infinity;
+  const maxComponents = typeof limits === "number" ? limits : limits.maxPathComponents ?? Infinity;
+  for (const value of [maxBytes, maxComponents]) {
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
+      throw new RangeError("Path limits must be nonnegative safe integers or Infinity");
+    }
+  }
   if (typeof path6 !== "string" || path6.includes("\0")) {
     throw new FsError("EINVAL", { syscall: "resolve", message: "paths must be strings without NUL bytes" });
   }
-  if (path6.length > MAX_PATH_BYTES) {
+  if (maxBytes !== Infinity && pathByteLength(path6) > maxBytes) {
     throw new FsError("ENAMETOOLONG", { syscall: "resolve", path: path6 });
   }
-  const limit = Math.min(maxComponents, MAX_PATH_COMPONENTS);
+  if (maxComponents === Infinity)
+    return;
+  const limit = maxComponents;
   let components2 = 0;
   let inComponent = false;
   for (let i = 0; i < path6.length; i++) {
@@ -14955,10 +15341,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 +15428,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 +15459,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;
@@ -15248,11 +15700,14 @@ function components(path6, signal) {
   }
   return result;
 }
-function resolveMissingTarget(root, path6, signal) {
-  const fail2 = (code, failedPath = path6) => {
+function resolveMissingTarget(root, path6, signal, limits = {}) {
+  validatePath(path6, limits);
+  const fail3 = (code, failedPath = path6) => {
     throw new FsError(code, { syscall: "realpath", path: failedPath });
   };
   const origin = components(path6, signal);
+  let remainingBytes = (limits.maxPathBytes ?? Infinity) - pathByteLength(path6);
+  let remainingComponents = (limits.maxPathComponents ?? Infinity) - origin.length;
   const initial = { node: root, name: "" };
   let position = initial;
   let links = 0;
@@ -15279,9 +15734,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 +15748,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,8 +15759,11 @@ function resolveMissingTarget(root, path6, signal) {
       first = false;
       if (node.type === "symlink") {
         if (++links > 40)
-          return fail2("ELOOP");
+          return fail3("ELOOP");
+        validatePath(node.target, { maxPathBytes: remainingBytes, maxPathComponents: remainingComponents });
         const names2 = components(node.target, signal);
+        remainingBytes -= pathByteLength(node.target);
+        remainingComponents -= names2.length;
         if (node.target.endsWith("/"))
           names2.push({ name: ".", start: node.target.length });
         if (node.target.startsWith("/"))
@@ -15326,7 +15784,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;
@@ -15509,26 +15967,22 @@ function readConfigRecord(value, label, keys) {
 
 // ../safe-fs/dist/fs/memory/limits.js
 var defaultMemoryFileSystemLimits = Object.freeze({
+  maxPathBytes: Infinity,
+  maxPathComponents: Infinity,
   maxFileBytes: Infinity,
   maxRetainedBytes: Infinity,
   maxMetadataUnits: Infinity
 });
 function normalizeMemoryFileSystemLimits(options) {
-  const keys = ["maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
+  const keys = ["maxPathBytes", "maxPathComponents", "maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
   const record3 = readConfigRecord(options, "memory option", [...keys, "maxBytes"]);
   const limits = { ...defaultMemoryFileSystemLimits };
-  if (Object.hasOwn(record3, "maxBytes") && record3.maxBytes !== void 0) {
-    if (typeof record3.maxBytes !== "number" || !Number.isSafeInteger(record3.maxBytes) || record3.maxBytes < 0) {
-      throw new RangeError("maxBytes must be a nonnegative safe integer");
-    }
-    limits.maxBytes = record3.maxBytes;
-  }
-  for (const key2 of keys) {
-    if (!Object.hasOwn(record3, key2))
-      continue;
+  for (const key2 of [...keys, "maxBytes"]) {
     const value = record3[key2];
+    if (value === void 0 || value === Infinity)
+      continue;
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (key2 === "maxMetadataUnits" ? 1 : 0)) {
-      throw new RangeError(`${key2} must be a ${key2 === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer`);
+      throw new RangeError(`${key2} must be a ${key2 === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer or Infinity`);
     }
     limits[key2] = value;
   }
@@ -15577,12 +16031,10 @@ var DUMMY_POOL_FILE_NODE = new MemoryFileNode(0, 0, null, 0, DUMMY_POOL_ALLOCATI
 DUMMY_POOL_FILE_NODE.atimeMs = DUMMY_POOL_FILE_NODE.mtimeMs = DUMMY_POOL_FILE_NODE.ctimeMs = DUMMY_POOL_FILE_NODE.birthtimeMs = 17e11;
 var defaultDateNow = Date.now;
 var fastWriteCachedNow = Date.now();
-var lastFastMapMiss = {
-  map: void 0,
-  key: "",
-  slot: -1
-};
 var FastDirectoryEntriesMap = class {
+  // Keep speculative slots local so a failed write cannot pin a tenant globally.
+  _missKey = "";
+  _missSlot = -1;
   _table = new Int16Array(128).fill(-1);
   _mask = 127;
   _keys = new Array(64).fill("");
@@ -15619,9 +16071,8 @@ var FastDirectoryEntriesMap = class {
   getForWriteWithHash(k, h) {
     let slot = h & this._mask;
     if (this.size === 0) {
-      lastFastMapMiss.map = this;
-      lastFastMapMiss.key = k;
-      lastFastMapMiss.slot = slot;
+      this._missKey = k;
+      this._missSlot = slot;
       return void 0;
     }
     const mask = this._mask;
@@ -15631,9 +16082,8 @@ var FastDirectoryEntriesMap = class {
     while (true) {
       const idx = table[slot];
       if (idx === -1) {
-        lastFastMapMiss.map = this;
-        lastFastMapMiss.key = k;
-        lastFastMapMiss.slot = firstDeleted !== -1 ? firstDeleted : slot;
+        this._missKey = k;
+        this._missSlot = firstDeleted !== -1 ? firstDeleted : slot;
         return void 0;
       }
       if (idx === -2) {
@@ -15682,6 +16132,7 @@ var FastDirectoryEntriesMap = class {
     return this.get(k) !== void 0;
   }
   _rebuild(newCap) {
+    this._missKey = "";
     const newTableLen = newCap * 2;
     const newMask = newTableLen - 1;
     const newTable = newCap <= 16384 ? new Int16Array(newTableLen).fill(-1) : new Int32Array(newTableLen).fill(-1);
@@ -15721,15 +16172,16 @@ var FastDirectoryEntriesMap = class {
     this._next = writeIdx;
   }
   set(k, v) {
-    if (this === lastFastMapMiss.map && k === lastFastMapMiss.key && this._next < this._keys.length) {
+    if (k === this._missKey && this._next < this._keys.length) {
       const entryIdx = this._next++;
-      this._table[lastFastMapMiss.slot] = entryIdx;
+      this._table[this._missSlot] = entryIdx;
       this._keys[entryIdx] = k;
       this._vals[entryIdx] = v;
       this.size++;
-      lastFastMapMiss.map = void 0;
+      this._missKey = "";
       return this;
     }
+    this._missKey = "";
     if (this._next >= this._keys.length) {
       this._rebuild(this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2);
     }
@@ -15760,6 +16212,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   delete(k) {
+    this._missKey = "";
     if (this.size === 0)
       return false;
     let slot = this._hash(k);
@@ -15785,6 +16238,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   clear() {
+    this._missKey = "";
     if (this._next > 0) {
       this._table.fill(-1);
       for (let i = 0; i < this._next; i++) {
@@ -16237,7 +16691,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const owner = ownedStores.get(this);
     if (path6 !== "")
       this.validatePath(path6, "realpath");
-    return resolveMissingTarget(owner.root, path6 || ".", options.signal);
+    return resolveMissingTarget(owner.root, path6 || ".", options.signal, this.ledger.limits);
   }
   async confineExtraction(roots, options = {}) {
     options.signal?.throwIfAborted();
@@ -16490,6 +16944,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
       this.fail("EINVAL", syscall, path6);
     if (path6.length === 0)
       this.fail("ENOENT", syscall, path6);
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
   }
   permission(node, mask, syscall, path6) {
     if ((node.mode >> 6 & mask) !== mask)
@@ -16511,6 +16967,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     node.mtimeMs = node.ctimeMs = now;
   }
   resolveNode(path6, syscall, followFinal = true) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     if (this.symlinkCount === 0 && isCleanAbsolutePath(path6)) {
       const fastDir = cache.lastFastDirNode;
@@ -16595,7 +17053,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         start = slash + 1;
       }
     }
-    let remainingPathUnits = 65536 - path6.length;
+    let remainingPathUnits = this.ledger.limits.maxPathBytes - pathByteLength(path6);
     if (remainingPathUnits < 0)
       this.fail("ENAMETOOLONG", syscall, path6);
     let initialComponents = 0;
@@ -16605,12 +17063,12 @@ var MemoryFileSystem = class _MemoryFileSystem {
         inComp = false;
       else if (!inComp) {
         inComp = true;
-        if (++initialComponents > 256)
+        if (++initialComponents > this.ledger.limits.maxPathComponents)
           this.fail("ENAMETOOLONG", syscall, path6);
       }
     }
-    const pending = path6.split("/").filter(Boolean);
-    let remainingComponents = 256 - pending.length;
+    let pending = path6.split("/").filter(Boolean);
+    let remainingComponents = this.ledger.limits.maxPathComponents - pending.length;
     if (path6.endsWith("/"))
       pending.push("");
     const stack = [{ node: this.root, name: "" }];
@@ -16660,9 +17118,9 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (node.type === "symlink" && (options.followFinal !== false || pending.length > 0)) {
         if (++links > 40)
           this.fail("ELOOP", syscall, path6);
-        if (node.target.length > remainingPathUnits)
+        if (pathByteLength(node.target) > remainingPathUnits)
           this.fail("ENAMETOOLONG", syscall, path6);
-        remainingPathUnits -= node.target.length;
+        remainingPathUnits -= pathByteLength(node.target);
         const target = node.target.split("/").filter(Boolean);
         if (target.length > remainingComponents)
           this.fail("ENAMETOOLONG", syscall, path6);
@@ -16671,7 +17129,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           target.push("");
         if (options.resizeCreate !== void 0 && target.at(-1) === "" && pending[0] === "")
           target.pop();
-        pending.unshift(...target);
+        pending = target.concat(pending);
         if (node.target.startsWith("/"))
           stack.splice(1);
         continue;
@@ -16687,6 +17145,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     };
   }
   file(path6, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     if (this.symlinkCount === 0 && path6.charCodeAt(0) === 47 && path6.length > 1 && path6.indexOf("/", 1) === -1 && !path6.includes("\0")) {
       const name = path6 === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path6, _lastFileSlice1Name = path6.slice(1));
       if (name !== "." && name !== "..") {
@@ -16961,6 +17421,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }, syscall, path6);
   }
   writeData(path6, data, options, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     if (!(data instanceof Uint8Array))
       throw new TypeError("Memory files require Uint8Array data");
     const target = this.prepareWrite(path6, options, syscall);
@@ -17077,9 +17539,11 @@ var MemoryFileSystem = class _MemoryFileSystem {
     this.changed(node, now);
   }
   writeMemoryFileFast(path6, data, append, mode) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path6, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     const syscall = append ? "appendFile" : "writeFile";
-    if (append && path6 === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+    if (append && path6 === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
       const current2 = cache.lastFastFileNode;
       const length2 = current2.byteLength + data.byteLength;
       this.admitSize(current2, length2, syscall, path6);
@@ -17093,7 +17557,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     let name = "";
     const cachedPrefix = cache.lastFastDirPrefix;
     const cachedDir = cache.lastFastDirNode;
-    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && cachedPrefix.length > 1 && path6.startsWith(cachedPrefix) && path6.indexOf("/", cachedPrefix.length) === -1) {
+    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && cachedPrefix.length > 1 && path6.startsWith(cachedPrefix) && path6.indexOf("/", cachedPrefix.length) === -1) {
       parent = cachedDir;
       name = path6.slice(cachedPrefix.length);
       if (exceedsComponentByteLimit2(name))
@@ -17106,7 +17570,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           name = path6.slice(start);
           if (exceedsComponentByteLimit2(name))
             this.fail("ENAMETOOLONG", syscall, path6);
-          if (start > 1 && (parent.mode & 1) !== 0) {
+          if (start > 1 && (parent.mode & 64) !== 0) {
             cache.lastFastDirPrefix = path6.slice(0, start);
             cache.lastFastDirNode = parent;
           }
@@ -17226,6 +17690,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         let ino = this.nextInode;
         this.nextInode = ino + batchCount;
         let nextIdx = 1;
+        entries2._missKey = "";
         entries2._next = 1 + batchCount;
         entries2.size = 1 + batchCount;
         const table = entries2._table;
@@ -17275,6 +17740,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
   }
   writeMemoryFileInDirFast(dirPrefix, name, data, append, mode, nameHash) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(dirPrefix + name, this.ledger.limits);
     const cache = this._cache;
     if (!append && dirPrefix === cache.lastFastDirPrefix && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 192) === 192 && name.length <= 85 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === void 0 && sharedFileNodePoolLen > 0) {
       const parent = cache.lastFastDirNode;
@@ -17302,12 +17769,11 @@ var MemoryFileSystem = class _MemoryFileSystem {
         node.allocation = DUMMY_POOL_ALLOCATION;
         node.sourceRef = node.data.subarray(0);
         const entryIdx = entries2._next++;
-        entries2._table[lastFastMapMiss.slot] = entryIdx;
+        entries2._table[entries2._missSlot] = entryIdx;
         entries2._keys[entryIdx] = name;
         entries2._vals[entryIdx] = node;
         entries2.size++;
-        lastFastMapMiss.map = void 0;
-        lastFastMapMiss.key = "";
+        entries2._missKey = "";
         this.ledger.reserve(name.length * 2, 2, "writeFile", name);
         this.totalBytes += length;
         this.mutationTick = this.mutationTick + 1 | 0;
@@ -17321,7 +17787,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
     const syscall = append ? "appendFile" : "writeFile";
     try {
-      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
         const current2 = cache.lastFastFileNode;
         const length2 = current2.byteLength + data.byteLength;
         this.admitSize(current2, length2, syscall, name);
@@ -17332,7 +17798,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       }
       let parent = this.root;
       const cachedDir = cache.lastFastDirNode;
-      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
+      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
         parent = cachedDir;
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
@@ -17357,7 +17823,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         this.permission(parent, 1, syscall, name);
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
-        if (dirPrefix.length > 1 && (parent.mode & 1) !== 0) {
+        if (dirPrefix.length > 1 && (parent.mode & 64) !== 0) {
           cache.lastFastDirPrefix = dirPrefix;
           cache.lastFastDirNode = parent;
         }
@@ -17433,11 +17899,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
             cache.lastFastFilePath = "";
             cache.lastFastFileName = name;
             cache.lastFastFileNode = node;
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
           } catch (error) {
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
             this.ledger.release(nameBytes, 2);
             throw error;
           }
@@ -19245,7 +19707,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 +19716,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 +19729,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);
@@ -19422,27 +19893,42 @@ function* parseXmlSteps(input, limits = {}) {
       throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
   };
   let pendingWork = 0;
-  const skipWhitespace = () => {
+  const skipWhitespace = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     return offset - start2;
   };
-  const scanName = () => {
+  const scanName = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c === 32 || c === 9 || c === 13 || c === 10 || c === 47 || c === 61 || c === 62 || c === 63)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     const name = source.slice(start2, offset);
+    pendingWork += offset - start2;
+    while (pendingWork >= 512) {
+      yield 512;
+      pendingWork -= 512;
+    }
     const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
-    return [name, prefix, localName, (offset - start2) * 2];
+    return [name, prefix, localName];
   };
   while (offset < source.length) {
     pendingWork += 1;
@@ -19463,7 +19949,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;
@@ -19479,11 +19965,15 @@ function* parseXmlSteps(input, limits = {}) {
         }
       } else {
         for (let index = 0; index < resolved.length; index++) {
+          pendingWork++;
+          if (pendingWork >= 512) {
+            yield 512;
+            pendingWork -= 512;
+          }
           const c = resolved.charCodeAt(index);
           if (c !== 32 && c !== 9 && c !== 13 && c !== 10)
             invalid("text outside the root");
         }
-        pendingWork += resolved.length;
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -19525,8 +20015,7 @@ function* parseXmlSteps(input, limits = {}) {
     } else if (source.startsWith("<?", offset)) {
       const start2 = offset;
       offset += 2;
-      const [target, , , wName] = scanName();
-      pendingWork += wName;
+      const [target] = yield* scanName();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -19565,21 +20054,25 @@ function* parseXmlSteps(input, limits = {}) {
       invalid("DTD and entity declarations are forbidden");
     } else if (source.charCodeAt(offset + 1) === 47) {
       offset += 2;
-      const [name, , , wName] = scanName();
-      pendingWork += wName + skipWhitespace();
+      const [name] = yield* scanName();
+      yield* skipWhitespace();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
       }
-      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;
-      const [name, prefix, localName, wName] = repeated ? [repeated.name, repeated.prefix, repeated.localName, repeated.name.length * 2] : scanName();
+      const [name, prefix, localName] = repeated ? [repeated.name, repeated.prefix, repeated.localName] : yield* scanName();
       if (repeated)
         offset += name.length;
-      pendingWork += wName;
+      if (repeated)
+        pendingWork += name.length * 2;
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -19589,19 +20082,17 @@ function* parseXmlSteps(input, limits = {}) {
       let namespaces = stack.at(-1)?.namespaces ?? /* @__PURE__ */ new Map([["xml", xmlNamespace]]);
       let ownsNamespaces = stack.length === 0;
       while (!repeated) {
-        const ws = skipWhitespace();
-        pendingWork += ws;
+        const ws = yield* skipWhitespace();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
         }
         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");
-        const [attribute, attrPrefix, attrLocal, wAttr] = scanName();
-        pendingWork += wAttr;
+        const [attribute, attrPrefix, attrLocal] = yield* scanName();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -19612,10 +20103,10 @@ function* parseXmlSteps(input, limits = {}) {
           throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
         if ((attributes?.size ?? 0) >= maxAttributesPerElement)
           throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         if (source[offset++] !== "=")
           invalid("missing attribute equals");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         const quote = source[offset++];
         if (quote !== '"' && quote !== "'")
           invalid("unquoted attribute");
@@ -19637,7 +20128,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 +20218,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 +20233,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;
 }
 
@@ -19794,14 +20293,13 @@ function scalar(element) {
 
 // ../safe-fs/dist/fs/webdav/webdav.js
 var timestampNamespace = "urn:virtual-bash:metadata";
-var maxTimestampPropertyBytes = 4096;
-function preflightTimestamps(property) {
+function preflightTimestamps(property, maxTimestampPropertyBytes) {
   let bytes = 0;
   for (const point of property.text) {
     const code = point.codePointAt(0);
     bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
     if (bytes > maxTimestampPropertyBytes)
-      throw new Error("timestamp property exceeds 4KiB limit");
+      throw new Error("timestamp property exceeds byte limit");
   }
   const text = scalar(property);
   let offset = 0;
@@ -20042,6 +20540,7 @@ var WebDavFileSystem = class {
   headers;
   maxResponseBytes;
   maxXmlBytes;
+  maxTimestampPropertyBytes;
   maxEntries;
   xmlLimits;
   timeoutMs;
@@ -20111,6 +20610,7 @@ var WebDavFileSystem = class {
       streamingAppend: this.requestStreamSupport !== false
     });
     this.maxResponseBytes = options.maxResponseBytes === void 0 ? Infinity : positive(options.maxResponseBytes, "maxResponseBytes", false, true);
+    this.maxTimestampPropertyBytes = positive(options.maxTimestampPropertyBytes ?? Infinity, "maxTimestampPropertyBytes", true, true);
     this.maxXmlBytes = options.maxXmlBytes === void 0 ? Infinity : positive(options.maxXmlBytes, "maxXmlBytes", false, true);
     this.xmlLimits = Object.freeze({ ...options.xmlLimits });
     for (const [name, value] of Object.entries(this.xmlLimits))
@@ -20546,7 +21046,7 @@ var WebDavFileSystem = class {
     let mtimeMs = date("getlastmodified") ?? 0;
     let atimeMs = 0;
     if (timestampProperty) {
-      const timestamps = JSON.parse(preflightTimestamps(timestampProperty));
+      const timestamps = JSON.parse(preflightTimestamps(timestampProperty, this.maxTimestampPropertyBytes));
       if (typeof timestamps !== "object" || timestamps === null || !("version" in timestamps) || timestamps.version !== 1 || !("etag" in timestamps) || typeof timestamps.etag !== "string" || !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(timestamps.etag) || !("type" in timestamps) || timestamps.type !== "file" && timestamps.type !== "directory" || !("atimeMs" in timestamps) || typeof timestamps.atimeMs !== "number" || !Number.isFinite(timestamps.atimeMs) || Math.abs(timestamps.atimeMs) > 864e13 || !("mtimeMs" in timestamps) || typeof timestamps.mtimeMs !== "number" || !Number.isFinite(timestamps.mtimeMs) || Math.abs(timestamps.mtimeMs) > 864e13)
         throw new Error("invalid timestamp property");
       if (timestamps.etag === validator && timestamps.type === (directory ? "directory" : "file")) {
@@ -21225,6 +21725,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 timestamp2 = (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: timestamp2("virtual-bash-mtime", modified),
+      atimeMs: timestamp2("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";
 
@@ -22258,8 +23972,10 @@ Redirect URI: ${textLine(request.redirectUri)}
 export {
   accessRemoteMcpResources,
   authenticateRemoteMcpServer,
+  beginRemoteMcpAuthorization,
   bindRemoteMcpConfiguration,
   compileToolArguments,
+  completeRemoteMcpAuthorization,
   createRemoteMcpCommands,
   createRemoteMcpManagementCommand,
   fetchRemoteMcpSchema,