@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/image-ast/index.browser.js

@@ -34253,7 +34253,7 @@ var CCITT_BLACK_CODES = /* @__PURE__ */ new Map([
 ]);
 function decodeCcittFax(bytes, parms) {
   const columns = Math.max(1, parms?.Columns ?? 1728);
-  const maxRows = parms?.Rows && parms.Rows > 0 ? parms.Rows : 2048;
+  const maxRows = parms?.Rows && parms.Rows > 0 ? parms.Rows : Infinity;
   const k = parms?.K ?? 0;
   const blackIs1 = parms?.BlackIs1 ?? false;
   const byteAlign = parms?.EncodedByteAlign ?? false;
@@ -57036,6 +57036,21 @@ var Duplex = class extends EventEmitter {
   }
 };
 
+// ../safe-fs/dist/platform/transport-budget.js
+var hasRegisteredS3FileSystem = false;
+function enableS3TransportBudget() {
+  hasRegisteredS3FileSystem = true;
+}
+var budgetKey = /* @__PURE__ */ Symbol("scoped-transport-budget");
+function chargeTransportOptions(options) {
+  for (const frame of options?.[budgetKey] ?? []) {
+    if (frame.credit > 0)
+      frame.credit--;
+    else
+      frame.admit(options);
+  }
+}
+
 // ../safe-fs/dist/platform/browser.js
 var platform = Object.freeze({
   nativeFileSystem: Object.freeze({ open: false, permissions: false, timestamps: false, conditionalChmod: false, trustedOwnedStaging: false, atomicRename: false }),
@@ -57076,6 +57091,10 @@ var comparisonContext = Object.freeze({
     }
   }
 });
+function chargeScopedTransportCall(options) {
+  options?.signal?.throwIfAborted();
+  chargeTransportOptions(options);
+}
 
 // ../safe-fs/dist/contracts/errors.js
 var descriptions = {
@@ -57187,6 +57206,48 @@ var EMPTY_BYTE_SOURCE = Object.freeze({
 });
 var noop = () => {
 };
+async function collectBytes(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)
@@ -57931,10 +57992,76 @@ async function compareEntries(filesystem, path, 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, path, stat, entry) {
+  observedStats.set(stat, { filesystem, path, 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();
@@ -57952,10 +58079,10 @@ function ownedResponseIdentifier(response, path) {
   return responses.get(response)?.get(path)?.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 (path, options) => {
@@ -57983,7 +58110,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;
@@ -58225,7 +58352,7 @@ function components(path, signal) {
   return result;
 }
 function resolveMissingTarget(root, path, signal) {
-  const fail2 = (code, failedPath = path) => {
+  const fail3 = (code, failedPath = path) => {
     throw new FsError(code, { syscall: "realpath", path: failedPath });
   };
   const origin = components(path, signal);
@@ -58255,9 +58382,9 @@ function resolveMissingTarget(root, path, 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;
@@ -58269,7 +58396,7 @@ function resolveMissingTarget(root, path, signal) {
         continue;
       }
       if (exceedsComponentByteLimit(name))
-        return fail2("ENAMETOOLONG");
+        return fail3("ENAMETOOLONG");
       const node = current.entries.get(name);
       if (!node) {
         found = false;
@@ -58280,7 +58407,7 @@ function resolveMissingTarget(root, path, signal) {
       first = false;
       if (node.type === "symlink") {
         if (++links > 40)
-          return fail2("ELOOP");
+          return fail3("ELOOP");
         const names2 = components(node.target, signal);
         if (node.target.endsWith("/"))
           names2.push({ name: ".", start: node.target.length });
@@ -58302,7 +58429,7 @@ function resolveMissingTarget(root, path, signal) {
     for (let count = origin.length; count > missing; count--) {
       signal?.throwIfAborted();
       if (count === missing + 1 && path[end - 1] !== "/")
-        return fail2("ENOENT", path.slice(0, end));
+        return fail3("ENOENT", path.slice(0, end));
       const last = origin[count - 1];
       if (!last)
         break;
@@ -62221,7 +62348,7 @@ function qualifiedNameSync(name, cache) {
   }
   return parts;
 }
-function* entities(text) {
+function* entities(text, recover) {
   let result = "";
   let offset = 0;
   while (offset < text.length) {
@@ -62230,8 +62357,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))
@@ -62239,8 +62370,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);
@@ -62439,7 +62575,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;
@@ -62547,8 +62683,11 @@ function* parseXmlSteps(input, limits = {}) {
         yield 512;
         pendingWork -= 512;
       }
-      if (source[offset++] !== ">" || stack.pop()?.name !== name)
-        invalid("mismatched closing tag");
+      if (source[offset++] !== ">" || stack.pop()?.name !== name) {
+        if (!limits.recover)
+          invalid("mismatched closing tag");
+        limits.recover("mismatched closing tag");
+      }
     } else {
       offset++;
       const repeated = previousEmpty && source.startsWith(previousEmpty.suffix, offset) ? previousEmpty : void 0;
@@ -62572,7 +62711,7 @@ function* parseXmlSteps(input, limits = {}) {
           pendingWork -= 512;
         }
         const ch3 = source.charCodeAt(offset);
-        if (ch3 === 47 || ch3 === 62)
+        if (ch3 === 47 || ch3 === 62 || limits.recover && offset === source.length)
           break;
         if (ws === 0)
           invalid("attributes require whitespace");
@@ -62613,7 +62752,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;
@@ -62703,8 +62842,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)
@@ -62715,8 +62857,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;
 }
 
@@ -64201,6 +64348,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, path, stat, metadata) {
+  if (!metadata)
+    return;
+  const entry = acceptedHeads.get(metadata);
+  acceptedHeads.delete(metadata);
+  if (entry)
+    recordS3Observation(filesystem, path, stat, entry);
+}
+
+// ../safe-fs/dist/fs/s3/transport.js
+function encodeCopySource(bucket, key) {
+  return [bucket, ...key.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 record2 = error;
+  const value = record2.Code ?? record2.code ?? record2.name;
+  return typeof value === "string" ? value : void 0;
+}
+function translate(error, syscall, path, 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, cause: error });
+}
+function fail2(code, syscall, path, message) {
+  throw new FsError(code, { syscall, path, ...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(path, options) {
+    options.signal?.throwIfAborted();
+    throw new FsError("ENOTSUP", { syscall: "open", path });
+  }
+  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, (path) => this.path(path), () => this.transport === transport && this.bucket === bucket && this.prefix === registeredPrefix, s3Comparison, options.compareEntry);
+    registerEntryAuthority(this, compareOwnedS3Entries);
+  }
+  async compareEntry(path, peer, peerPath, options = {}) {
+    return compareEntries(this, path, 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 path = `/${components2.join("/")}`;
+    if (utf8ByteLength3(this.key(path)) > 1024)
+      fail2("ENAMETOOLONG", "resolve", input);
+    return path;
+  }
+  key(path) {
+    return this.prefix + path.slice(1);
+  }
+  directoryKey(path) {
+    const key = path === "/" ? this.prefix : `${this.key(path)}/`;
+    if (utf8ByteLength3(key) > 1024)
+      fail2("ENAMETOOLONG", "resolve", path);
+    return key;
+  }
+  checkAbort(options, syscall, path) {
+    if (options.signal?.aborted)
+      fail2("ECANCELED", syscall, path);
+  }
+  requestOptions(options) {
+    return options.signal === void 0 ? {} : { abortSignal: options.signal };
+  }
+  async call(syscall, path, options, action, precondition) {
+    this.checkAbort(options, syscall, path);
+    chargeScopedTransportCall(options);
+    this.checkAbort(options, syscall, path);
+    const budget = this.removalBudgets.get(options);
+    if (budget && ++budget.requests > this.removalLimits.maxRequests) {
+      fail2("EFBIG", "rm", path, "S3 removal request budget exceeded");
+    }
+    if (this.requests >= this.maxRequests) {
+      fail2("EFBIG", syscall, path, "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, 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, path);
+      return result;
+    } catch (error) {
+      if (options.signal?.aborted)
+        fail2("ECANCELED", syscall, path);
+      throw translate(error, syscall, path, precondition);
+    } finally {
+      if (onAbort)
+        options.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  writable(path, mode) {
+    if (this.capabilities.readOnly)
+      fail2("EROFS", "write", path);
+    if (mode !== void 0)
+      validateLimit(mode, "mode", 0, 4095);
+  }
+  unsupported(operation, path) {
+    return fail2("ENOTSUP", operation, path, `S3 does not support ${operation} with the configured transport`);
+  }
+  async head(key, path, options) {
+    try {
+      const input = { Bucket: this.bucket, Key: key };
+      return await this.call("headObject", path, options, () => queryS3Head(input, (query) => this.transport.headObject(query, this.requestOptions(options))));
+    } catch (error) {
+      if (isFsError(error, "ENOENT") && serviceCode(error.cause) !== "NoSuchBucket")
+        return void 0;
+      throw error;
+    }
+  }
+  makeStat(type, metadata) {
+    const size = type === "directory" ? 0 : metadata?.ContentLength;
+    if (size === void 0 || !Number.isSafeInteger(size) || size < 0)
+      fail2("EIO", "stat", "", "transport omitted a valid object ContentLength");
+    const modified = metadata?.LastModified?.getTime() ?? 0;
+    if (!Number.isFinite(modified))
+      fail2("EIO", "stat", "", "transport returned an invalid LastModified");
+    const timestamp = (key, fallback) => {
+      const value = metadata?.Metadata?.[key];
+      if (value === void 0)
+        return fallback;
+      const parsed = Number(value);
+      if (!value || !Number.isFinite(parsed))
+        fail2("EIO", "stat", "", "invalid virtual timestamp metadata");
+      return parsed;
+    };
+    const storedMode = metadata?.Metadata?.["virtual-bash-mode"];
+    const mode = storedMode === void 0 ? type === "directory" ? 493 : 420 : Number(storedMode);
+    if (!Number.isSafeInteger(mode) || mode < 0 || mode > 4095 || storedMode === "")
+      fail2("EIO", "stat", "", "invalid virtual mode metadata");
+    return {
+      type,
+      size,
+      mode: (type === "directory" ? 16384 : 32768) | mode,
+      mtimeMs: timestamp("virtual-bash-mtime", modified),
+      atimeMs: timestamp("virtual-bash-atime", 0),
+      ctimeMs: modified
+    };
+  }
+  async page(prefix, path, 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", path, 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", path, "S3 removal listing budget exceeded");
+    }
+    for (const item of result.Contents ?? []) {
+      if (typeof item.Key !== "string" || !item.Key.startsWith(prefix))
+        fail2("EIO", "listObjectsV2", path, "transport returned an object outside the requested prefix");
+      this.validateObject(item, path);
+    }
+    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", path, "invalid common prefix");
+      this.validateKey(item.Prefix, path);
+    }
+    if (result.IsTruncated !== void 0 && typeof result.IsTruncated !== "boolean")
+      fail2("EIO", "listObjectsV2", path, "invalid IsTruncated flag");
+    return result;
+  }
+  validateKey(key, path) {
+    if (!key.startsWith(this.prefix))
+      fail2("EIO", "listObjectsV2", path, "key escapes the configured prefix");
+    const relative = key.slice(this.prefix.length).replace(/\/$/, "");
+    if (!isWellFormed(key) || key.includes("\0") || utf8ByteLength3(key) > 1024 || relative !== "" && relative.split("/").some((part) => !part || part === "." || part === "..")) {
+      fail2("ENOTSUP", "listObjectsV2", path, "object key cannot be represented as a canonical filesystem path");
+    }
+  }
+  validateObject(object, path) {
+    const key = object.Key;
+    this.validateKey(key, path);
+    if (object.Size === void 0 || !Number.isSafeInteger(object.Size) || object.Size < 0)
+      fail2("EIO", "listObjectsV2", path, "invalid object size");
+    if (key.endsWith("/") && object.Size !== 0)
+      fail2("ENOTSUP", "listObjectsV2", path, "nonempty slash-suffixed objects cannot be treated as directories");
+  }
+  async *pages(prefix, path, options, delimiter, maxKeys = this.pageSize) {
+    const tokens = /* @__PURE__ */ new Set();
+    let token;
+    let entries2 = 0;
+    do {
+      const page = await this.page(prefix, path, options, delimiter, token, maxKeys);
+      entries2 += (page.Contents?.length ?? 0) + (page.CommonPrefixes?.length ?? 0);
+      if (entries2 > this.maxListEntries || tokens.size >= this.maxListEntries)
+        fail2("EFBIG", "listObjectsV2", path, "listing exceeds maxListEntries");
+      yield page;
+      if (!page.IsTruncated)
+        return;
+      token = page.NextContinuationToken;
+      if (typeof token !== "string" || !token || tokens.has(token))
+        fail2("EIO", "listObjectsV2", path, "missing or repeated continuation token");
+      tokens.add(token);
+    } while (true);
+  }
+  async inspect(path, options) {
+    if (path === "/") {
+      const listing = await this.page(this.prefix, path, options, void 0, void 0, 1);
+      const marker2 = this.prefix && listing.Contents?.some((object) => object.Key === this.prefix) ? await this.head(this.prefix, path, options) : void 0;
+      if (marker2 && marker2.ContentLength !== 0)
+        this.unsupported("nonempty directory markers", path);
+      return { stat: this.makeStat("directory", marker2), ...marker2 ? { metadata: marker2 } : {} };
+    }
+    const file = await this.head(this.key(path), path, options);
+    if (utf8ByteLength3(this.key(path)) === 1024) {
+      return file ? { stat: this.makeStat("file", file), metadata: file } : void 0;
+    }
+    const directoryKey = this.directoryKey(path);
+    let directory = false;
+    let hasMarker = false;
+    for await (const children of this.pages(directoryKey, path, options, void 0, 1)) {
+      if ((children.Contents?.length ?? 0) > 0) {
+        directory = true;
+        hasMarker = children.Contents.some((object) => object.Key === directoryKey);
+        break;
+      }
+    }
+    const marker = hasMarker ? await this.head(directoryKey, path, options) : void 0;
+    if (marker && marker.ContentLength !== 0)
+      this.unsupported("nonempty directory markers", path);
+    if (file && directory)
+      this.unsupported("file/prefix collisions", path);
+    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(path, options) {
+    const ancestors = [];
+    for (let parent = posixPath.dirname(path); path !== "/"; 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(path, options);
+  }
+  requireDirectorySuffix(input, info3) {
+    if (input.endsWith("/") && info3?.stat.type === "file")
+      fail2("ENOTDIR", "stat", input);
+  }
+  async stat(input, options = {}) {
+    const path = this.path(input);
+    const info3 = await this.lookup(path, options);
+    this.requireDirectorySuffix(input, info3);
+    if (!info3)
+      fail2("ENOENT", "stat", input);
+    recordS3Stat(this, path, info3.stat, info3.metadata);
+    return info3.stat;
+  }
+  async lstat(path, options = {}) {
+    return this.stat(path, options);
+  }
+  async body(output, path, 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", path, 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", path);
+      const body = output.Body;
+      if (!body)
+        fail2("EIO", "readFile", path, "transport omitted the response body");
+      let bytes;
+      if (body instanceof Uint8Array) {
+        if (body.byteLength > limit)
+          fail2("EFBIG", "readFile", path);
+        bytes = new Uint8Array(body);
+      } else if (Symbol.asyncIterator in body) {
+        bytes = await collectBytes({ [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", path, "transport body is not binary");
+        if (converted.byteLength > limit)
+          fail2("EFBIG", "readFile", path);
+        bytes = new Uint8Array(converted);
+      } else
+        fail2("EIO", "readFile", path, "unsupported response body");
+      this.checkAbort(options, "readFile", path);
+      if (output.ContentLength !== void 0 && output.ContentLength !== bytes.byteLength)
+        fail2("EIO", "readFile", path, "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(path, options) {
+    return this.call("getObject", path, options, () => this.transport.getObject({ Bucket: this.bucket, Key: this.key(path) }, this.requestOptions(options)));
+  }
+  async readFile(input, options = {}) {
+    const path = this.path(input);
+    if (options.maxBytes !== void 0)
+      validateLimit(options.maxBytes, "maxBytes", 0, Infinity);
+    const info3 = await this.stat(input, options);
+    if (info3.type === "directory")
+      fail2("EISDIR", "readFile", path);
+    if (info3.size > Math.min(this.maxReadBytes, options.maxBytes ?? this.maxReadBytes))
+      fail2("EFBIG", "readFile", path);
+    const output = this.capabilities.streamingRead ? await this.call("getObject", path, options, () => this.transport.getObjectStream({ Bucket: this.bucket, Key: this.key(path) }, this.requestOptions(options))) : await this.get(path, options);
+    return this.body(output, path, options);
+  }
+  etag(metadata, path) {
+    if (!metadata?.ETag)
+      this.unsupported("conditional mutation without an ETag", path);
+    return metadata.ETag;
+  }
+  async writeFile(input, data, options = {}) {
+    const path = this.path(input);
+    this.writable(path, options.mode);
+    if (!(data instanceof Uint8Array))
+      fail2("EINVAL", "writeFile", path, "data must be Uint8Array");
+    const bytes = new Uint8Array(data);
+    if (bytes.byteLength > 5e9)
+      fail2("EFBIG", "writeFile", path, "multipart upload is not supported");
+    const flag = options.flag ?? "w";
+    if (!["w", "wx", "a", "ax"].includes(flag))
+      fail2("EINVAL", "writeFile", path, "invalid write flag");
+    if (flag !== "w" && !this.transport.capabilities?.conditionalPut)
+      this.unsupported("conditional writes", path);
+    const info3 = await this.lookup(path, options);
+    this.requireDirectorySuffix(input, info3);
+    if (info3?.stat.type === "directory")
+      fail2("EISDIR", "writeFile", path);
+    if (input.endsWith("/"))
+      fail2("EISDIR", "writeFile", input);
+    const exclusive = flag === "wx" || flag === "ax";
+    if (exclusive && info3)
+      fail2("EEXIST", "writeFile", path);
+    let body = bytes;
+    let match;
+    let metadata = this.writeMetadata(info3?.metadata, options.mode);
+    if (flag === "a" && info3) {
+      const current = await this.get(path, options);
+      const previous = await this.body(current, path, options);
+      match = this.etag(current, path);
+      metadata = { ...current.Metadata };
+      delete metadata["virtual-bash-mtime"];
+      if (previous.length + bytes.length > this.maxReadBytes)
+        fail2("EFBIG", "appendFile", path);
+      body = new Uint8Array(previous.length + bytes.length);
+      body.set(previous);
+      body.set(bytes, previous.length);
+    }
+    await this.call("putObject", path, options, () => this.transport.putObject({
+      Bucket: this.bucket,
+      Key: this.key(path),
+      Body: body,
+      ...match === void 0 ? {} : { IfMatch: match },
+      ...exclusive || flag === "a" && !info3 ? { 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(path, data, options = {}) {
+    return this.writeFile(path, data, { ...options, flag: "a" });
+  }
+  async mkdir(input, options = {}) {
+    const path = this.path(input);
+    this.writable(path, options.mode);
+    if (options.recursive && path !== "/") {
+      await this.mkdir(posixPath.dirname(path), { ...options, recursive: true });
+    }
+    const info3 = await this.lookup(path, options);
+    if (info3) {
+      if (options.recursive && info3.stat.type === "directory")
+        return;
+      fail2("EEXIST", "mkdir", path);
+    }
+    await this.call("putObject", path, options, () => this.transport.putObject({
+      Bucket: this.bucket,
+      Key: this.directoryKey(path),
+      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 path = this.path(input);
+    if ((await this.stat(input, options)).type !== "directory")
+      fail2("ENOTDIR", "readdir", path);
+    const prefix = this.directoryKey(path);
+    const entries2 = /* @__PURE__ */ new Map();
+    const add = (name, type) => {
+      this.checkAbort(options, "readdir", path);
+      if (!name || name.includes("/"))
+        fail2("EIO", "readdir", path, "invalid direct child in delimited listing");
+      const existing = entries2.get(name);
+      if (existing && existing.type !== type)
+        this.unsupported("file/prefix collisions", path);
+      if (!existing)
+        admitDirectoryEntries(entries2.size + 1, limit, path);
+      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, path, 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(path, options) {
+    const objects = /* @__PURE__ */ new Map();
+    for await (const page of this.pages(this.directoryKey(path), path, options)) {
+      for (const item of page.Contents ?? [])
+        objects.set(item.Key, item);
+    }
+    for (const key of objects.keys()) {
+      const withoutSlash = key.replace(/\/$/, "");
+      if (key.endsWith("/") && objects.has(withoutSlash))
+        this.unsupported("file/prefix collisions", path);
+      let parent = posixPath.dirname(withoutSlash);
+      while (parent !== "." && parent !== "/") {
+        if (objects.has(parent))
+          this.unsupported("file/prefix collisions", path);
+        parent = posixPath.dirname(parent);
+      }
+    }
+    return [...objects.values()];
+  }
+  async rmdir(input, options = {}) {
+    try {
+      const path = this.path(input);
+      this.checkAbort(options, "rmdir", input);
+      this.writable(path);
+      if (path === "/")
+        fail2("EBUSY", "rmdir", input, "cannot remove the mounted root");
+      const info3 = await this.lookup(path, options);
+      this.checkAbort(options, "rmdir", input);
+      if (!info3)
+        fail2("ENOENT", "rmdir", input);
+      if (info3.stat.type !== "directory")
+        fail2("ENOTDIR", "rmdir", input);
+      const prefix = this.directoryKey(path);
+      let markerObserved = false;
+      for await (const page of this.pages(prefix, path, 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 (!info3.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", path, 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 path = this.path(input);
+    this.writable(path);
+    if (path === "/")
+      fail2("EBUSY", "rm", path, "cannot remove the mounted root");
+    let info3;
+    try {
+      info3 = await this.lookup(path, options);
+    } catch (error) {
+      if (options.force && isFsError(error, "ENOENT") && serviceCode(error.cause) !== "NoSuchBucket")
+        return;
+      throw error;
+    }
+    this.requireDirectorySuffix(input, info3);
+    if (!info3) {
+      if (options.force)
+        return;
+      fail2("ENOENT", "rm", path);
+    }
+    let objects;
+    if (info3.stat.type === "directory" && !options.recursive) {
+      const prefix = this.directoryKey(path);
+      objects = [];
+      for await (const page of this.pages(prefix, path, options, void 0, 2)) {
+        if (page.Contents?.some((item) => item.Key !== prefix))
+          fail2("ENOTEMPTY", "rm", path);
+        if (page.Contents?.length)
+          objects = [{ Key: prefix }];
+      }
+    } else {
+      objects = info3.stat.type === "directory" ? await this.tree(path, options) : [{ Key: this.key(path) }];
+    }
+    if (objects.length > this.removalLimits.maxDeleteObjects || budget.requests + objects.length > this.removalLimits.maxRequests) {
+      fail2("EFBIG", "rm", path, "S3 removal delete or request budget exceeded; use bounded batches");
+    }
+    for (const item of objects) {
+      await this.call("deleteObject", path, 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 object of objects) {
+      this.etag({ ETag: object.ETag }, source);
+      if (object.Size === void 0 || object.Size > 5e9)
+        this.unsupported("multipart copy", source);
+      if (!conditionalCopy && object.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) + object.Key.slice(this.key(source).length)) > 1024)
+        fail2("ENAMETOOLONG", "rename", destination);
+    }
+    const copied = [];
+    const deleted = [];
+    let phase = "copy";
+    try {
+      for (const object of objects) {
+        const destinationKey = this.key(destination) + object.Key.slice(this.key(source).length);
+        const destinationMetadata = origin.stat.type === "file" || object.Key === this.directoryKey(source) ? target?.metadata ?? null : null;
+        const metadata = { ContentLength: object.Size, ETag: object.ETag };
+        if (conditionalCopy)
+          await this.copy(object.Key, destinationKey, source, metadata, options, destinationMetadata);
+        else
+          await this.copyWithPut(object.Key, destinationKey, source, metadata, destinationMetadata, options, streamFallback);
+        copied.push(destinationKey);
+      }
+      phase = "delete";
+      for (const object of objects) {
+        await this.call("deleteObject", source, options, () => this.transport.deleteObject({
+          Bucket: this.bucket,
+          Key: object.Key,
+          IfMatch: object.ETag
+        }, this.requestOptions(options)));
+        deleted.push(object.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(path, mode = 0, options = {}) {
+    if (!Number.isInteger(mode) || mode < 0 || mode > 7)
+      fail2("EINVAL", "access", path);
+    const info3 = await this.stat(path, options);
+    if ((mode & 2) !== 0 && this.capabilities.readOnly)
+      fail2("EROFS", "access", path);
+    if ((mode & 1) !== 0 && info3.type !== "directory")
+      fail2("EACCES", "access", path);
+  }
+  async readlink(path) {
+    return this.unsupported("readlink", path);
+  }
+  async symlink(_target, path) {
+    this.unsupported("symlink", path);
+  }
+  async link(_existingPath, path) {
+    this.unsupported("link", path);
+  }
+  async chmod(path, _mode) {
+    this.unsupported("chmod", path);
+  }
+  async utimes(input, atimeMs, mtimeMs, options = {}) {
+    const path = this.path(input);
+    this.writable(path);
+    if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs))
+      fail2("EINVAL", "utimes", path);
+    const info3 = await this.lookup(path, options);
+    this.requireDirectorySuffix(input, info3);
+    if (!info3)
+      fail2("ENOENT", "utimes", path);
+    if (!this.capabilities.timestamps)
+      this.unsupported("conditional metadata mutation", path);
+    const key = info3.stat.type === "directory" ? this.directoryKey(path) : this.key(path);
+    if (!key)
+      this.unsupported("timestamps on an unprefixed bucket root", path);
+    const metadata = {
+      ...info3.metadata?.Metadata,
+      "virtual-bash-atime": String(atimeMs),
+      "virtual-bash-mtime": String(mtimeMs)
+    };
+    if (!info3.metadata) {
+      if (!this.transport.capabilities?.conditionalPut)
+        this.unsupported("conditional directory marker creation", path);
+      await this.call("utimes", path, options, () => this.transport.putObject({
+        Bucket: this.bucket,
+        Key: key,
+        Body: new Uint8Array(),
+        Metadata: metadata,
+        IfNoneMatch: "*"
+      }, this.requestOptions(options)));
+      return;
+    }
+    if (!this.transport.capabilities?.conditionalCopy) {
+      const current = await this.call("getObject", path, options, () => this.transport.getObject({
+        Bucket: this.bucket,
+        Key: key
+      }, this.requestOptions(options)));
+      const body = await this.body(current, path, options);
+      await this.call("utimes", path, options, () => this.transport.putObject({
+        Bucket: this.bucket,
+        Key: key,
+        Body: body,
+        IfMatch: this.etag(current, path),
+        Metadata: { ...current.Metadata, "virtual-bash-atime": String(atimeMs), "virtual-bash-mtime": String(mtimeMs) }
+      }, this.requestOptions(options)));
+      return;
+    }
+    if (info3.stat.size > 5e9)
+      this.unsupported("multipart metadata copy", path);
+    const etag = this.etag(info3.metadata, path);
+    const result = await this.call("utimes", path, options, () => this.transport.copyObject({
+      Bucket: this.bucket,
+      Key: key,
+      CopySource: encodeCopySource(this.bucket, key),
+      CopySourceIfMatch: etag,
+      IfMatch: etag,
+      MetadataDirective: "REPLACE",
+      Metadata: metadata
+    }, this.requestOptions(options)));
+    if (!result.CopyObjectResult?.ETag)
+      fail2("EIO", "utimes", path, "transport did not confirm a completed metadata copy");
+  }
+  async truncate(input, length = 0, options = {}) {
+    const path = this.path(input);
+    this.writable(path);
+    validateLimit(length, "length", 0);
+    const info3 = await this.lookup(path, options);
+    this.requireDirectorySuffix(input, info3);
+    if (!info3)
+      fail2("ENOENT", "truncate", path);
+    if (info3.stat.type === "directory")
+      fail2("EISDIR", "truncate", path);
+    if (!this.transport.capabilities?.conditionalPut)
+      this.unsupported("conditional truncate", path);
+    if (length > this.maxReadBytes)
+      fail2("EFBIG", "truncate", path);
+    let current = info3.metadata;
+    const body = new Uint8Array(length);
+    if (length !== 0 && info3.stat.size !== 0) {
+      if (this.readStream) {
+        const previous = await this.call("truncate", path, options, () => collectBytes(this.readStream(input, { ...options, endExclusive: Math.min(length, info3.stat.size) }), { ...options, maxBytes: length }));
+        body.set(previous);
+      } else {
+        const output = await this.get(path, options);
+        const previous = await this.body(output, path, options);
+        current = output;
+        body.set(previous.subarray(0, length));
+      }
+    }
+    const metadata = { ...current.Metadata };
+    delete metadata["virtual-bash-mtime"];
+    await this.call("truncate", path, options, () => this.transport.putObject({
+      Bucket: this.bucket,
+      Key: this.key(path),
+      Body: body,
+      IfMatch: this.etag(current, path),
+      Metadata: metadata
+    }, this.requestOptions(options)));
+  }
+  async *streamRead(input, options = {}) {
+    const path = 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 chunkSize2 = validateLimit(options.chunkSize ?? 64 * 1024, "chunkSize", 1);
+    const info3 = await this.lookup(path, options);
+    this.requireDirectorySuffix(input, info3);
+    if (!info3)
+      fail2("ENOENT", "readStream", path);
+    if (info3.stat.type === "directory")
+      fail2("EISDIR", "readStream", path);
+    const stop = Math.min(end ?? info3.stat.size, info3.stat.size);
+    const expected = Math.max(0, stop - start);
+    if (expected > this.maxStreamBytes)
+      fail2("EFBIG", "readStream", path);
+    if (expected === 0 && info3.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", path, options, () => this.transport.getObjectStream({
+        Bucket: this.bucket,
+        Key: this.key(path),
+        IfMatch: this.etag(info3.metadata, path),
+        ...expected === 0 || start === 0 && stop === info3.stat.size ? {} : { Range: `bytes=${start}-${stop - 1}` }
+      }, { abortSignal: signal }));
+      if (output.ETag !== void 0 && output.ETag !== info3.metadata?.ETag)
+        fail2("EIO", "readStream", path, "response ETag differs from requested snapshot");
+      if (output.ContentLength !== void 0 && output.ContentLength !== expected)
+        fail2("EIO", "readStream", path, "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", path, "response exceeds requested length");
+        count += chunk.length;
+        for (let offset = 0; offset < chunk.length; offset += chunkSize2) {
+          this.checkAbort(options, "readStream", path);
+          yield new Uint8Array(chunk.subarray(offset, offset + chunkSize2));
+        }
+      }
+      if (count !== expected)
+        fail2("EIO", "readStream", path, "incomplete response body");
+      finished = true;
+    } catch (error) {
+      this.checkAbort(options, "readStream", path);
+      throw translate(error, "readStream", path);
+    } 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 path = this.path(input);
+    this.writable(path, options.mode);
+    const flag = options.flag ?? "w";
+    if (!["w", "wx", "a", "ax"].includes(flag))
+      fail2("EINVAL", "writeStream", path);
+    if (flag !== "w" && !this.transport.capabilities?.conditionalPut)
+      this.unsupported("conditional writes", path);
+    const info3 = await this.lookup(path, options);
+    this.requireDirectorySuffix(input, info3);
+    if (info3?.stat.type === "directory" || input.endsWith("/"))
+      fail2("EISDIR", "writeStream", path);
+    const exclusive = flag === "wx" || flag === "ax";
+    if (exclusive && info3)
+      fail2("EEXIST", "writeStream", path);
+    if (flag === "a") {
+      const current = info3 ? await this.get(path, options) : void 0;
+      const previous = current ? await this.body(current, path, options) : new Uint8Array();
+      const limit = Math.min(this.maxReadBytes, this.maxStreamBytes);
+      if (previous.length > limit)
+        fail2("EFBIG", "writeStream", path);
+      const bytes = await this.call("writeStream", path, options, () => collectBytes(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", path, options, () => this.transport.putObject({
+        Bucket: this.bucket,
+        Key: this.key(path),
+        Body: body2,
+        ...current ? { IfMatch: this.etag(current, path) } : { 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", path);
+        total += chunk.length;
+        for (let offset = 0; offset < chunk.length; offset += 64 * 1024) {
+          this.checkAbort({ signal }, "writeStream", path);
+          yield new Uint8Array(chunk.subarray(offset, offset + 64 * 1024));
+        }
+      }
+      finished = true;
+    }).call(this);
+    try {
+      const metadata = this.writeMetadata(info3?.metadata, options.mode);
+      await this.call("putObject", path, options, () => this.transport.putObjectStream({
+        Bucket: this.bucket,
+        Key: this.key(path),
+        Body: body,
+        ...exclusive ? { IfNoneMatch: "*" } : {},
+        ...metadata === void 0 ? {} : { Metadata: metadata }
+      }, { abortSignal: signal }), exclusive ? "EEXIST" : "EAGAIN");
+      if (!finished)
+        fail2("EIO", "writeStream", path, "transport completed without consuming the request body");
+    } finally {
+      controller.abort();
+      signalScope?.dispose();
+      this.dispose(body);
+    }
+  }
+};
+var s3Comparison = S3FileSystem.prototype.compareEntry;
+
 // src/sharp.ts
 function inferTypedArrayDepth(input) {
   if (!input || !ArrayBuffer.isView(input)) return void 0;