create-monolayer-app 0.2.2 → 0.3.0

package/template/vendor/file-bucket/vite.js

@@ -0,0 +1,2482 @@
+import { createServer } from "node:http";
+import path, { dirname, join } from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import { crc32 } from "node:zlib";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeSync } from "node:fs";
+//#region src/server/context.ts
+/**
+* Execution context and multi-tenancy account scoping.
+*/
+const DEFAULT_ACCOUNT_ID = "000000000000";
+const DEFAULT_REGION = process.env.AWS_REGION || "us-east-1";
+const asyncLocalStorage = new AsyncLocalStorage();
+function getAccountId() {
+	const store = asyncLocalStorage.getStore();
+	return store ? store.accountId : DEFAULT_ACCOUNT_ID;
+}
+function getRegion() {
+	const store = asyncLocalStorage.getStore();
+	return store ? store.region : DEFAULT_REGION;
+}
+function withAccountContext(context, fn) {
+	const current = asyncLocalStorage.getStore();
+	const next = {
+		accountId: context.accountId ?? current?.accountId ?? DEFAULT_ACCOUNT_ID,
+		region: context.region ?? current?.region ?? DEFAULT_REGION
+	};
+	return asyncLocalStorage.run(next, fn);
+}
+/**
+* Helper to serialize arbitrary key types (strings or tuples) to string keys.
+*/
+function serializeKey(key) {
+	if (Array.isArray(key)) return JSON.stringify(key);
+	return String(key);
+}
+function asKey(value) {
+	return value;
+}
+function deserializeKey(rawKey) {
+	if (rawKey.startsWith("[") && rawKey.endsWith("]")) try {
+		return JSON.parse(rawKey);
+	} catch {
+		return asKey(rawKey);
+	}
+	return asKey(rawKey);
+}
+/**
+* AccountScopedMap stores values partitioned by account ID.
+* When operations (get, set, has, delete, keys, etc.) are performed, they are
+* implicitly scoped to the current account ID from getAccountId().
+*/
+var AccountScopedMap = class {
+	_data = /* @__PURE__ */ new Map();
+	makeCompositeKey(key, accountId = getAccountId()) {
+		return `${accountId}::${serializeKey(key)}`;
+	}
+	get(key, accountId) {
+		return this._data.get(this.makeCompositeKey(key, accountId));
+	}
+	set(key, value, accountId) {
+		this._data.set(this.makeCompositeKey(key, accountId), value);
+		return this;
+	}
+	has(key, accountId) {
+		return this._data.has(this.makeCompositeKey(key, accountId));
+	}
+	delete(key, accountId) {
+		return this._data.delete(this.makeCompositeKey(key, accountId));
+	}
+	keys(accountId = getAccountId()) {
+		const prefix = `${accountId}::`;
+		const result = [];
+		for (const k of this._data.keys()) if (k.startsWith(prefix)) result.push(deserializeKey(k.slice(prefix.length)));
+		return result;
+	}
+	entries(accountId = getAccountId()) {
+		const prefix = `${accountId}::`;
+		const result = [];
+		for (const [k, v] of this._data.entries()) if (k.startsWith(prefix)) result.push([deserializeKey(k.slice(prefix.length)), v]);
+		return result;
+	}
+};
+//#endregion
+//#region src/server/utils.ts
+/**
+* General utilities: formatting, hashing, parsing, UUIDs, dates.
+*/
+function nowIso() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isoToRfc7231(iso) {
+	const date = iso instanceof Date ? iso : new Date(iso);
+	if (Number.isNaN(date.getTime())) return (/* @__PURE__ */ new Date()).toUTCString();
+	return date.toUTCString();
+}
+function parseHttpDate(value) {
+	if (!value) return null;
+	const parsed = Date.parse(value);
+	if (Number.isNaN(parsed)) return null;
+	return new Date(parsed);
+}
+function newUuid() {
+	return randomUUID();
+}
+function md5Hex(data) {
+	return createHash("md5").update(data).digest("hex");
+}
+function sha256Hex(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+/**
+* S3 percent-encoding for `encoding-type=url`.
+* Encodes characters per RFC 3986, but leaves "/" intact when safeSlash=true.
+*/
+function urlEncode(value, safeSlash = true) {
+	const encoded = encodeURIComponent(value).replaceAll(/[!'()*]/gu, (c) => {
+		return `%${(c.codePointAt(0) ?? 0).toString(16).toUpperCase()}`;
+	});
+	if (safeSlash) return encoded.replaceAll("%2F", "/");
+	return encoded;
+}
+function urlDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Parse query string into a Record<string, string | string[]>.
+*/
+function parseQueryParams(query) {
+	const result = Object.create(null);
+	if (!query) return result;
+	const queryString = query.startsWith("?") ? query.slice(1) : query;
+	if (!queryString) return result;
+	const pairs = queryString.split("&");
+	for (const pair of pairs) {
+		if (!pair) continue;
+		const [rawKey, ...rest] = pair.split("=");
+		const rawVal = rest.join("=");
+		const key = urlDecode(rawKey);
+		const val = urlDecode(rawVal);
+		if (key in result) {
+			const existing = result[key];
+			if (Array.isArray(existing)) existing.push(val);
+			else result[key] = [existing, val];
+		} else result[key] = val;
+	}
+	return result;
+}
+/**
+* Helper to retrieve first query param value, matching Python `_qp(params, key, default)`.
+*/
+function qp(params, key, defaultValue = "") {
+	if (!params) return defaultValue;
+	const val = params[key];
+	if (val === void 0) return defaultValue;
+	if (Array.isArray(val)) return val.length > 0 ? val[0] : defaultValue;
+	return val;
+}
+//#endregion
+//#region src/server/xml.ts
+/**
+* Zero-dependency XML parser, DOM builder, and serializer for S3 XML payloads.
+*/
+const S3_NS = "http://s3.amazonaws.com/doc/2006-03-01/";
+const XML_DECL = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+var ParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ParseError";
+	}
+};
+function escapeXml(str) {
+	if (str === null || str === void 0) return "";
+	return String(str).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+function unescapeXml(str) {
+	return str.replaceAll("&quot;", "\"").replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&").replaceAll(/&#(\d+);/gu, (_, dec) => String.fromCodePoint(Math.trunc(Number(dec)))).replaceAll(/&#x([0-9a-fA-F]+);/gu, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16)));
+}
+/**
+* Strips namespace prefix or Clark notation from a tag name.
+* e.g. "{http://...}Rule" -> "Rule", "s3:Rule" -> "Rule", "Rule" -> "Rule"
+*/
+function localTagName(tag) {
+	if (tag.startsWith("{")) {
+		const idx = tag.indexOf("}");
+		if (idx !== -1) return tag.slice(idx + 1);
+	}
+	const colonIdx = tag.indexOf(":");
+	if (colonIdx !== -1) return tag.slice(colonIdx + 1);
+	return tag;
+}
+function isString(value) {
+	return typeof value === "string";
+}
+var XmlElement = class XmlElement {
+	tag;
+	attrs;
+	text;
+	children;
+	constructor(tag, attrs = {}, text) {
+		this.tag = tag;
+		this.attrs = { ...attrs };
+		this.text = text;
+		this.children = [];
+	}
+	localName() {
+		return localTagName(this.tag);
+	}
+	subElement(tag, textOrAttrs, text) {
+		const el = isString(textOrAttrs) ? new XmlElement(tag, {}, textOrAttrs) : new XmlElement(tag, textOrAttrs || {}, text);
+		this.children.push(el);
+		return el;
+	}
+	find(tag) {
+		const targetLocal = localTagName(tag);
+		return this.children.find((c) => c.tag === tag || c.localName() === targetLocal);
+	}
+	findAll(tag) {
+		const targetLocal = localTagName(tag);
+		return this.children.filter((c) => c.tag === tag || c.localName() === targetLocal);
+	}
+	findText(tag) {
+		return this.find(tag)?.text;
+	}
+	findDescendant(tag) {
+		const targetLocal = localTagName(tag);
+		for (const c of this.children) {
+			if (c.tag === tag || c.localName() === targetLocal) return c;
+			const deep = c.findDescendant(tag);
+			if (deep) return deep;
+		}
+	}
+	findAllDescendants(tag) {
+		const targetLocal = localTagName(tag);
+		const result = [];
+		for (const c of this.children) {
+			if (c.tag === tag || c.localName() === targetLocal) result.push(c);
+			result.push(...c.findAllDescendants(tag));
+		}
+		return result;
+	}
+	iter() {
+		const result = [this];
+		for (const child of this.children) result.push(...child.iter());
+		return result;
+	}
+	toXml(includeDeclaration = false) {
+		let s = includeDeclaration ? `${XML_DECL}\n` : "";
+		s += `<${this.tag}`;
+		for (const [k, v] of Object.entries(this.attrs)) s += ` ${k}="${escapeXml(v)}"`;
+		if (this.children.length === 0 && this.text === void 0) {
+			s += "/>";
+			return s;
+		}
+		s += ">";
+		if (this.text !== void 0) s += escapeXml(this.text);
+		for (const child of this.children) s += child.toXml(false);
+		s += `</${this.tag}>`;
+		return s;
+	}
+};
+function parseXml(xml) {
+	let str = (typeof xml === "string" ? xml : xml.toString("utf-8")).trim();
+	if (!str) throw new ParseError("Empty XML document");
+	if (str.startsWith("<?xml")) {
+		const end = str.indexOf("?>");
+		if (end !== -1) str = str.slice(end + 2).trim();
+	}
+	let pos = 0;
+	const len = str.length;
+	let root = null;
+	const stack = [];
+	while (pos < len) {
+		const lt = str.indexOf("<", pos);
+		if (lt === -1) {
+			if (stack.length > 0) {
+				const text = unescapeXml(str.slice(pos).trim());
+				const top = stack.at(-1);
+				if (text && top) top.text = (top.text || "") + text;
+			}
+			break;
+		}
+		if (lt > pos && stack.length > 0) {
+			const text = unescapeXml(str.slice(pos, lt).trim());
+			const top = stack.at(-1);
+			if (text && top) top.text = (top.text || "") + text;
+		}
+		pos = lt + 1;
+		if (str.startsWith("!--", pos)) {
+			const end = str.indexOf("-->", pos + 3);
+			pos = end === -1 ? len : end + 3;
+			continue;
+		}
+		if (str.startsWith("![CDATA[", pos)) {
+			const end = str.indexOf("]]>", pos + 8);
+			const cdata = end === -1 ? str.slice(pos + 8) : str.slice(pos + 8, end);
+			const top = stack.at(-1);
+			if (top) top.text = (top.text || "") + cdata;
+			pos = end === -1 ? len : end + 3;
+			continue;
+		}
+		if (str.startsWith("?", pos) || str.startsWith("!", pos)) {
+			const gt = str.indexOf(">", pos);
+			pos = gt === -1 ? len : gt + 1;
+			continue;
+		}
+		if (str[pos] === "/") {
+			const gt = str.indexOf(">", pos);
+			if (gt === -1) throw new ParseError("Unclosed closing tag");
+			const closeTag = str.slice(pos + 1, gt).trim();
+			const open = stack.pop();
+			if (!open) throw new ParseError(`Unexpected closing tag: </${closeTag}>`);
+			if (localTagName(open.tag) !== localTagName(closeTag) && open.tag !== closeTag) throw new ParseError(`Mismatched closing tag: expected </${open.tag}>, got </${closeTag}>`);
+			pos = gt + 1;
+			continue;
+		}
+		const gt = str.indexOf(">", pos);
+		if (gt === -1) throw new ParseError("Unclosed opening tag");
+		let tagBody = str.slice(pos, gt).trim();
+		const selfClosing = tagBody.endsWith("/");
+		if (selfClosing) tagBody = tagBody.slice(0, -1).trim();
+		const spaceIdx = tagBody.search(/\s/u);
+		const tagName = spaceIdx === -1 ? tagBody : tagBody.slice(0, spaceIdx);
+		const attrs = {};
+		if (spaceIdx !== -1) {
+			const attrStr = tagBody.slice(spaceIdx).trim();
+			const attrRegex = /([a-zA-Z0-9_:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gu;
+			let m;
+			while ((m = attrRegex.exec(attrStr)) !== null) attrs[m[1]] = unescapeXml(m[2] ?? m[3] ?? m[4] ?? "");
+		}
+		const el = new XmlElement(tagName, attrs);
+		const top = stack.at(-1);
+		if (top) top.children.push(el);
+		else {
+			if (root) throw new ParseError("Multiple root elements found in XML document");
+			root = el;
+		}
+		if (!selfClosing) stack.push(el);
+		pos = gt + 1;
+	}
+	const lastUnclosed = stack.at(-1);
+	if (lastUnclosed) throw new ParseError(`Unclosed element: <${lastUnclosed.tag}>`);
+	if (!root) throw new ParseError("Empty XML document");
+	return root;
+}
+function xmlBody(root) {
+	return Buffer.from(`${XML_DECL}\n${root.toXml(false)}`, "utf-8");
+}
+//#endregion
+//#region src/server/errors.ts
+function s3Error(code, message, status, resource = "") {
+	const root = new XmlElement("Error");
+	root.subElement("Code", code);
+	root.subElement("Message", message);
+	root.subElement("Resource", resource);
+	root.subElement("RequestId", newUuid());
+	return [
+		status,
+		{ "Content-Type": "application/xml" },
+		xmlBody(root)
+	];
+}
+function noSuchBucket(bucketName) {
+	return s3Error("NoSuchBucket", "The specified bucket does not exist", 404, `/${bucketName}`);
+}
+function noSuchKey(bucketName, key, deleteMarkerHeaders) {
+	const [status, headers, body] = s3Error("NoSuchKey", "The specified key does not exist.", 404, `/${bucketName}/${key}`);
+	if (deleteMarkerHeaders) Object.assign(headers, deleteMarkerHeaders);
+	return [
+		status,
+		headers,
+		body
+	];
+}
+function noSuchVersion(bucketName, key) {
+	return s3Error("NoSuchVersion", "The specified version does not exist.", 404, `/${bucketName}/${key}`);
+}
+function preconditionFailed(message = "At least one of the pre-conditions you specified did not hold", resource = "") {
+	return s3Error("PreconditionFailed", message, 412, resource);
+}
+function invalidRange(bucketName, key, totalSize) {
+	const root = new XmlElement("Error");
+	root.subElement("Code", "InvalidRange");
+	root.subElement("Message", "The requested range is not satisfiable");
+	root.subElement("Resource", `/${bucketName}/${key}`);
+	root.subElement("RequestId", newUuid());
+	return [
+		416,
+		{
+			"Content-Type": "application/xml",
+			"Content-Range": `bytes */${totalSize}`
+		},
+		xmlBody(root)
+	];
+}
+function notModified(respHeaders) {
+	const payloadHeaders = /* @__PURE__ */ new Set([
+		"content-length",
+		"content-type",
+		"content-encoding",
+		"accept-ranges"
+	]);
+	const headers = {};
+	for (const [k, v] of Object.entries(respHeaders)) {
+		const lk = k.toLowerCase();
+		if (!payloadHeaders.has(lk) && !lk.startsWith("x-amz-checksum-")) headers[k] = v;
+	}
+	return [
+		304,
+		headers,
+		Buffer.alloc(0)
+	];
+}
+//#endregion
+//#region src/server/types.ts
+const S3_CHECKSUM_ALGORITHMS = [
+	"CRC32",
+	"CRC32C",
+	"CRC64NVME",
+	"SHA1",
+	"SHA256"
+];
+//#endregion
+//#region src/server/checksums.ts
+/**
+* S3 Checksums implementation: CRC64NVME, CRC32C, CRC32, SHA1, SHA256,
+* Content-MD5 validation, and composite multipart checksums.
+*/
+const CRC64NVME_POLY = 11127430586519243189n;
+const CRC64NVME_INIT = 18446744073709551615n;
+const CRC64NVME_TABLE = (() => {
+	const table = /* @__PURE__ */ new BigInt64Array(256);
+	for (let i = 0; i < 256; i += 1) {
+		let crc = BigInt(i);
+		for (let j = 0; j < 8; j += 1) crc = (crc & 1n) === 0n ? crc >> 1n : crc >> 1n ^ CRC64NVME_POLY;
+		table[i] = crc;
+	}
+	return table;
+})();
+function crc64nvme(body) {
+	let crc = CRC64NVME_INIT;
+	for (let i = 0; i < body.length; i += 1) {
+		const idx = Number((crc ^ BigInt(body[i])) & 255n);
+		crc = (CRC64NVME_TABLE[idx] ^ crc >> 8n) & 18446744073709551615n;
+	}
+	return (crc ^ CRC64NVME_INIT) & 18446744073709551615n;
+}
+const CRC32C_POLY = 2197175160;
+const CRC32C_INIT = 4294967295;
+const CRC32C_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let i = 0; i < 256; i += 1) {
+		let crc = i >>> 0;
+		for (let j = 0; j < 8; j += 1) crc = (crc & 1) === 0 ? crc >>> 1 >>> 0 : (crc >>> 1 ^ CRC32C_POLY) >>> 0;
+		table[i] = crc;
+	}
+	return table;
+})();
+function crc32c(body) {
+	let crc = CRC32C_INIT;
+	for (let i = 0; i < body.length; i += 1) {
+		const idx = (crc ^ body[i]) & 255;
+		crc = (CRC32C_TABLE[idx] ^ crc >>> 8) >>> 0;
+	}
+	return (crc ^ CRC32C_INIT) >>> 0;
+}
+/**
+* Compute the base64-encoded checksum for the given algorithm name.
+*/
+function computeS3Checksum(algorithm, body) {
+	const algo = (algorithm || "").toUpperCase().replaceAll("_", "");
+	if (algo === "SHA256") return createHash("sha256").update(body).digest("base64");
+	if (algo === "SHA1") return createHash("sha1").update(body).digest("base64");
+	if (algo === "CRC32") {
+		const crc = crc32(body) >>> 0;
+		const buf = Buffer.alloc(4);
+		buf.writeUInt32BE(crc, 0);
+		return buf.toString("base64");
+	}
+	if (algo === "CRC32C") {
+		const crc = crc32c(body);
+		const buf = Buffer.alloc(4);
+		buf.writeUInt32BE(crc, 0);
+		return buf.toString("base64");
+	}
+	if (algo === "CRC64NVME") {
+		const crc = crc64nvme(body);
+		const buf = Buffer.alloc(8);
+		buf.writeBigUInt64BE(crc, 0);
+		return buf.toString("base64");
+	}
+	return null;
+}
+/**
+* Validate Content-MD5 header on write requests.
+*/
+function validateContentMd5(headers, body) {
+	const md5Header = headers["content-md5"] || "";
+	if (!md5Header) return null;
+	let expected;
+	try {
+		expected = Buffer.from(md5Header, "base64");
+		if (expected.toString("base64") !== md5Header.trim()) return s3Error("InvalidDigest", "The Content-MD5 you specified is not valid.", 400);
+	} catch {
+		return s3Error("InvalidDigest", "The Content-MD5 you specified is not valid.", 400);
+	}
+	if (expected.length !== 16) return s3Error("InvalidDigest", "The Content-MD5 you specified is not valid.", 400);
+	const actual = createHash("md5").update(body).digest();
+	if (!expected.equals(actual)) return s3Error("BadDigest", "The Content-MD5 you specified did not match what we received.", 400);
+	return null;
+}
+const CHECKSUM_HEADERS_LOWER = [
+	"crc32",
+	"crc32c",
+	"crc64nvme",
+	"sha1",
+	"sha256"
+];
+function resolveObjectChecksums(body, headers) {
+	const provided = {};
+	const unverifiable = [];
+	for (const alg of CHECKSUM_HEADERS_LOWER) {
+		const headerVal = headers[`x-amz-checksum-${alg}`];
+		if (headerVal) {
+			const uAlg = alg.toUpperCase();
+			provided[uAlg] = headerVal;
+			if (computeS3Checksum(uAlg, Buffer.alloc(0)) === null) unverifiable.push(uAlg);
+		}
+	}
+	const sdkAlgRaw = headers["x-amz-sdk-checksum-algorithm"];
+	let sdkKey = null;
+	if (sdkAlgRaw) {
+		sdkKey = sdkAlgRaw.toUpperCase().replaceAll("_", "");
+		if (computeS3Checksum(sdkAlgRaw, Buffer.alloc(0)) === null) unverifiable.push(sdkKey);
+	}
+	if (unverifiable.length > 0) return {
+		checksums: {},
+		error: s3Error("InvalidRequest", `Checksum algorithm not supported: ${unverifiable.sort().join(", ")}. Supported: SHA256, SHA1, CRC32, CRC32C, CRC64NVME.`, 400)
+	};
+	for (const [alg, supplied] of Object.entries(provided)) {
+		const computed = computeS3Checksum(alg, body);
+		if (computed !== null && supplied !== computed) return {
+			checksums: {},
+			error: s3Error("BadDigest", `The ${alg} you specified did not match the calculated checksum.`, 400)
+		};
+	}
+	const checksums = { ...provided };
+	if (sdkAlgRaw && sdkKey) {
+		const computed = computeS3Checksum(sdkAlgRaw, body);
+		if (computed !== null) checksums[sdkKey] = computed;
+	}
+	return {
+		checksums,
+		error: null
+	};
+}
+function resolveMultipartChecksumAlgorithm(headers) {
+	const raw = headers["x-amz-checksum-algorithm"] || headers["x-amz-sdk-checksum-algorithm"];
+	if (!raw) return {
+		algorithm: null,
+		error: null
+	};
+	const algorithm = raw.toUpperCase().replaceAll("_", "");
+	if (!S3_CHECKSUM_ALGORITHMS.includes(algorithm)) return {
+		algorithm: null,
+		error: s3Error("InvalidRequest", `Checksum algorithm not supported: ${algorithm}. Supported: SHA256, SHA1, CRC32, CRC32C, CRC64NVME.`, 400)
+	};
+	return {
+		algorithm,
+		error: null
+	};
+}
+function resolvePartChecksums(body, headers, upload) {
+	const { checksums, error } = resolveObjectChecksums(body, headers);
+	if (error) return {
+		checksums: {},
+		error
+	};
+	const algorithm = upload.checksumAlgorithm;
+	if (algorithm && !(algorithm in checksums)) {
+		const computed = computeS3Checksum(algorithm, body);
+		if (computed !== null) checksums[algorithm] = computed;
+	}
+	return {
+		checksums,
+		error: null
+	};
+}
+function compositeChecksum(algorithm, partChecksums) {
+	if (!algorithm || partChecksums.length === 0) return null;
+	const chunks = [];
+	for (const val of partChecksums) {
+		if (!val) return null;
+		try {
+			chunks.push(Buffer.from(val, "base64"));
+		} catch {
+			return null;
+		}
+	}
+	const digest = computeS3Checksum(algorithm, Buffer.concat(chunks));
+	if (!digest) return null;
+	return `${digest}-${partChecksums.length}`;
+}
+//#endregion
+//#region src/server/cors.ts
+/** S3 permits a single wildcard in origins and header patterns. */
+function matches(pattern, value) {
+	const wildcard = pattern.indexOf("*");
+	if (wildcard === -1) return pattern === value;
+	return value.length >= pattern.length - 1 && value.startsWith(pattern.slice(0, wildcard)) && value.endsWith(pattern.slice(wildcard + 1));
+}
+function corsResponseHeaders(configuration, method, headers) {
+	const origin = headers["origin"];
+	if (!origin || !configuration) return void 0;
+	const preflight = method === "OPTIONS";
+	const requestedMethod = preflight ? headers["access-control-request-method"] : method;
+	const requestedHeaders = preflight ? (headers["access-control-request-headers"] || "").split(",").map((header) => header.trim().toLowerCase()).filter(Boolean) : [];
+	try {
+		for (const rule of parseXml(configuration).findAll("CORSRule")) {
+			const origins = rule.findAll("AllowedOrigin").map((element) => element.text || "");
+			const methods = rule.findAll("AllowedMethod").map((element) => element.text || "");
+			const allowedHeaders = rule.findAll("AllowedHeader").map((element) => (element.text || "").toLowerCase());
+			if (!origins.some((pattern) => matches(pattern, origin)) || !methods.includes(requestedMethod) || !requestedHeaders.every((header) => allowedHeaders.some((pattern) => matches(pattern, header)))) continue;
+			const result = {
+				"Access-Control-Allow-Origin": origin,
+				Vary: "Origin, Access-Control-Request-Method, Access-Control-Request-Headers"
+			};
+			if (preflight) {
+				result["Access-Control-Allow-Methods"] = methods.join(", ");
+				if (requestedHeaders.length) result["Access-Control-Allow-Headers"] = requestedHeaders.join(", ");
+				const maxAge = rule.findText("MaxAgeSeconds");
+				if (maxAge !== void 0) result["Access-Control-Max-Age"] = maxAge;
+			}
+			const exposed = rule.findAll("ExposeHeader").map((element) => element.text || "");
+			if (exposed.length) result["Access-Control-Expose-Headers"] = exposed.join(", ");
+			return result;
+		}
+	} catch {}
+}
+//#endregion
+//#region src/server/lifecycle.ts
+function days(element, name) {
+	const value = Number(element.findText(name));
+	if (!Number.isInteger(value) || value < 1) throw new Error("Lifecycle days must be positive integers.");
+	return value;
+}
+function onlyChildren(element, names) {
+	if (element.children.some((child) => !names.includes(child.localName()))) throw new Error("Unsupported lifecycle configuration.");
+}
+function parseLifecycleXml(body) {
+	const root = parseXml(body);
+	if (root.localName() !== "LifecycleConfiguration") throw new Error("Invalid lifecycle root.");
+	onlyChildren(root, ["Rule"]);
+	return root.findAll("Rule").map((element) => {
+		onlyChildren(element, [
+			"ID",
+			"Status",
+			"Filter",
+			"Expiration",
+			"Transition",
+			"AbortIncompleteMultipartUpload"
+		]);
+		const status = element.findText("Status");
+		if (status !== "Enabled" && status !== "Disabled") throw new Error("Invalid lifecycle status.");
+		const rule = {
+			ID: element.findText("ID"),
+			Status: status
+		};
+		const filter = element.find("Filter");
+		if (filter) {
+			onlyChildren(filter, ["Prefix"]);
+			rule.Filter = { Prefix: filter.findText("Prefix") };
+		}
+		const expiration = element.find("Expiration");
+		if (expiration) {
+			onlyChildren(expiration, ["Days"]);
+			rule.Expiration = { Days: days(expiration, "Days") };
+		}
+		rule.Transitions = element.findAll("Transition").map((transition) => {
+			onlyChildren(transition, ["Days", "StorageClass"]);
+			if (transition.findText("StorageClass") !== "STANDARD_IA") throw new Error("Unsupported lifecycle transition.");
+			return {
+				Days: days(transition, "Days"),
+				StorageClass: "STANDARD_IA"
+			};
+		});
+		const abort = element.find("AbortIncompleteMultipartUpload");
+		if (abort) {
+			onlyChildren(abort, ["DaysAfterInitiation"]);
+			rule.AbortIncompleteMultipartUpload = { DaysAfterInitiation: days(abort, "DaysAfterInitiation") };
+		}
+		return rule;
+	});
+}
+//#endregion
+//#region src/server/sigv4.ts
+/**
+* AWS Signature Version 4 (SigV4) presigned URL verification and header hoisting.
+*/
+const SIGV4_UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
+const EXTRA_URI_CHARACTERS = /[!'()*]/gu;
+const PRESIGN_SIGNING_PARAMS = /* @__PURE__ */ new Set([
+	"x-amz-algorithm",
+	"x-amz-credential",
+	"x-amz-date",
+	"x-amz-expires",
+	"x-amz-signedheaders",
+	"x-amz-signature",
+	"x-amz-security-token",
+	"x-amz-content-sha256"
+]);
+/**
+* RFC 3986 URI encoding per SigV4 specification:
+* Unreserved characters (A-Za-z0-9-_.~) remain literal; everything else is percent-encoded.
+* If encodeSlash is false, "/" is preserved (used for path components).
+*/
+function uriEncode(value, encodeSlash = true) {
+	const encoded = encodeURIComponent(value).replaceAll(EXTRA_URI_CHARACTERS, (character) => `%${character.codePointAt(0)?.toString(16).toUpperCase()}`);
+	return encodeSlash ? encoded : encoded.replaceAll("%2F", "/");
+}
+function sigv4SigningKey(secret, dateStamp, region, service) {
+	const hmac = (key, msg) => {
+		return createHmac("sha256", key).update(msg, "utf-8").digest();
+	};
+	return hmac(hmac(hmac(hmac(`AWS4${secret}`, dateStamp), region), service), "aws4_request");
+}
+function resolvePresignSecret(_accessKeyId) {
+	return process.env.AWS_SECRET_ACCESS_KEY || "test";
+}
+function hasAnyPresignParam(queryParams) {
+	for (const key of Object.keys(queryParams)) if (PRESIGN_SIGNING_PARAMS.has(key.toLowerCase())) return true;
+	return false;
+}
+function hasDuplicatePresignParams(queryParams) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const [key, val] of Object.entries(queryParams)) {
+		const lk = key.toLowerCase();
+		if (PRESIGN_SIGNING_PARAMS.has(lk)) {
+			if (seen.has(lk) || Array.isArray(val)) return true;
+			seen.add(lk);
+		}
+	}
+	return false;
+}
+function verifyPresignedSigV4(method, path, headers, queryParams) {
+	if (!hasAnyPresignParam(queryParams)) return null;
+	const badSignature = () => {
+		return s3Error("SignatureDoesNotMatch", "The request signature we calculated does not match the signature you provided. Check your key and signing method.", 403, path);
+	};
+	if (hasDuplicatePresignParams(queryParams)) return s3Error("AuthorizationQueryParametersError", "Duplicate query parameter in request.", 400, path);
+	const signature = qp(queryParams, "X-Amz-Signature") || qp(queryParams, "x-amz-signature");
+	const algorithm = qp(queryParams, "X-Amz-Algorithm") || qp(queryParams, "x-amz-algorithm");
+	const credential = qp(queryParams, "X-Amz-Credential") || qp(queryParams, "x-amz-credential");
+	const amzDate = qp(queryParams, "X-Amz-Date") || qp(queryParams, "x-amz-date");
+	const signedHeaders = qp(queryParams, "X-Amz-SignedHeaders") || qp(queryParams, "x-amz-signedheaders");
+	if (!algorithm || algorithm !== "AWS4-HMAC-SHA256") return badSignature();
+	if (!signature || !credential || !amzDate || !signedHeaders) return badSignature();
+	const credParts = credential.split("/");
+	if (credParts.length !== 5 || credParts[4] !== "aws4_request" || credParts[3] !== "s3") return badSignature();
+	const [akid, dateStamp, region, service] = credParts;
+	const m = amzDate.match(/^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z$/u);
+	if (!m || amzDate.slice(0, 8) !== dateStamp) return badSignature();
+	const expires = qp(queryParams, "X-Amz-Expires") || qp(queryParams, "x-amz-expires");
+	if (!/^\d+$/u.test(expires) || Number(expires) < 1 || Number(expires) > 604800) return s3Error("AuthorizationQueryParametersError", "X-Amz-Expires must be a valid integer between 1 and 604800.", 400, path);
+	const signedAt = /* @__PURE__ */ new Date(`${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}Z`);
+	if (!Number.isFinite(signedAt.getTime()) || signedAt.toISOString().replaceAll(/[-:]/gu, "").replace(".000", "") !== amzDate) return badSignature();
+	if (!akid || !region) return badSignature();
+	const requiredHeaders = signedHeaders.split(";");
+	const presentHeaders = new Set(Object.keys(headers).map((header) => header.toLowerCase()));
+	if (!requiredHeaders.includes("host") || new Set(requiredHeaders).size !== requiredHeaders.length || requiredHeaders.toSorted().join(";") !== signedHeaders || requiredHeaders.some((header) => !/^[a-z0-9-]+$/u.test(header) || !presentHeaders.has(header))) return badSignature();
+	if (Date.now() >= signedAt.getTime() + Number(expires) * 1e3) return s3Error("AccessDenied", "Request has expired", 403, path);
+	if (signedAt.getTime() > Date.now() + 9e5) return badSignature();
+	const pairs = [];
+	for (const [name, values] of Object.entries(queryParams)) {
+		if (name.toLowerCase() === "x-amz-signature") continue;
+		const vlist = Array.isArray(values) ? values : [values];
+		for (const v of vlist) pairs.push([uriEncode(name), uriEncode(v ?? "")]);
+	}
+	pairs.sort((a, b) => {
+		const left = a[0] === b[0] ? a[1] : a[0];
+		const right = a[0] === b[0] ? b[1] : b[0];
+		if (left < right) return -1;
+		return left > right ? 1 : 0;
+	});
+	const canonicalQs = pairs.map(([k, v]) => `${k}=${v}`).join("&");
+	let canonicalHeaders = "";
+	const headerList = signedHeaders.split(";").filter(Boolean);
+	const lowerHeaders = {};
+	for (const [k, v] of Object.entries(headers)) lowerHeaders[k.toLowerCase()] = v;
+	for (const hname of headerList) {
+		const lh = hname.toLowerCase();
+		const collapsed = (lowerHeaders[lh] ?? "").toString().trim().replaceAll(/\s+/gu, " ");
+		canonicalHeaders += `${lh}:${collapsed}\n`;
+	}
+	const canonicalRequest = [
+		method,
+		path,
+		canonicalQs,
+		canonicalHeaders,
+		signedHeaders,
+		SIGV4_UNSIGNED_PAYLOAD
+	].join("\n");
+	const stringToSign = [
+		"AWS4-HMAC-SHA256",
+		amzDate,
+		`${dateStamp}/${region}/${service}/aws4_request`,
+		sha256Hex(canonicalRequest)
+	].join("\n");
+	const signingKey = sigv4SigningKey(resolvePresignSecret(akid), dateStamp, region, service);
+	const computed = createHmac("sha256", signingKey).update(stringToSign, "utf-8").digest("hex");
+	const computedBuf = Buffer.from(computed.toLowerCase(), "utf-8");
+	const providedBuf = Buffer.from(signature.toLowerCase(), "utf-8");
+	if (computedBuf.length !== providedBuf.length || !timingSafeEqual(computedBuf, providedBuf)) return badSignature();
+	return null;
+}
+/**
+* Merges hoisted `x-amz-*` query parameters into the request headers.
+*/
+function mergeHoistedAmzHeaders(headers, queryParams) {
+	let hoisted = null;
+	for (const [name, values] of Object.entries(queryParams)) {
+		const lname = name.toLowerCase();
+		if (!lname.startsWith("x-amz-") || PRESIGN_SIGNING_PARAMS.has(lname)) continue;
+		if (lname in headers) continue;
+		const val = Array.isArray(values) ? values[0] : values;
+		if (val === void 0 || val === null) continue;
+		if (!hoisted) hoisted = { ...headers };
+		hoisted[lname] = String(val);
+	}
+	return hoisted ?? headers;
+}
+//#endregion
+//#region src/server/storage-schema.ts
+const BODY_REFERENCE = /^[a-f0-9]{64}$/u;
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+	return typeof value === "string";
+}
+function timestamp(value) {
+	return text(value) && Number.isFinite(Date.parse(value));
+}
+function size(value) {
+	return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function strings(value) {
+	return record(value) && Object.values(value).every(text);
+}
+function optional(value, check) {
+	return value === void 0 || check(value);
+}
+function bodyFields(value, version) {
+	return text(value.etag) && timestamp(value.lastModified) && size(value.size) && optional(value.contentType, text) && optional(value.contentEncoding, text) && optional(value.metadata, strings) && optional(value.preservedHeaders, strings) && optional(value.checksums, strings) && optional(value.checksumType, (type) => type === "FULL_OBJECT" || type === "COMPOSITE") && optional(value.bodyRef, (ref) => text(ref) && BODY_REFERENCE.test(ref)) && (version < 2 || value.isDeleteMarker === true || text(value.bodyRef));
+}
+function object(value, version) {
+	return record(value) && value.body === null && (version < 2 || text(value.bodyRef)) && text(value.contentType) && strings(value.metadata) && strings(value.preservedHeaders) && strings(value.checksums) && optional(value.versionId, (id) => id === null || text(id)) && bodyFields(value, version);
+}
+function versions(value, version) {
+	return Array.isArray(value) && value.every((item) => record(item) && text(item.versionId) && typeof item.isLatest === "boolean" && optional(item.isDeleteMarker, (flag) => typeof flag === "boolean") && (item.data === void 0 || item.data === null) && bodyFields(item, version));
+}
+function positive(value) {
+	return size(value) && Number(value) > 0;
+}
+function lifecycle(value) {
+	return Array.isArray(value) && value.every((rule) => record(rule) && (rule.Status === "Enabled" || rule.Status === "Disabled") && optional(rule.ID, text) && optional(rule.Filter, (filter) => record(filter) && optional(filter.Prefix, text)) && optional(rule.Expiration, (expiry) => record(expiry) && positive(expiry.Days)) && optional(rule.AbortIncompleteMultipartUpload, (abort) => record(abort) && positive(abort.DaysAfterInitiation)) && optional(rule.Transitions, (transitions) => Array.isArray(transitions) && transitions.every((entry) => record(entry) && positive(entry.Days) && entry.StorageClass === "STANDARD_IA")));
+}
+function isValidState(value) {
+	if (!record(value)) throw new Error("Corrupted persistence state manifest: expected object.");
+	if (value.version !== void 0 && value.version !== 1 && value.version !== 2) throw new Error(`Unsupported persistence state manifest version: ${String(value.version)}`);
+	const version = Number(value.version ?? 1);
+	const map = (input, check) => record(input) && Object.entries(input).every(([key, entry]) => key.includes("::") && check(entry));
+	const optionalMap = (input, check) => version < 2 && input === void 0 || map(input, check);
+	if (!map(value.buckets_meta, (bucket) => record(bucket) && timestamp(bucket.created) && text(bucket.region) && record(bucket.objects) && Object.values(bucket.objects).every((entry) => object(entry, version))) || !optionalMap(value.bucket_versioning, (entry) => entry === "Enabled" || entry === "Suspended") || !optionalMap(value.bucket_cors, text) || !optionalMap(value.bucket_lifecycle, lifecycle) || !optionalMap(value.object_versions, (entry) => versions(entry, version))) throw new Error("Corrupted persistence state manifest: invalid state schema.");
+	return true;
+}
+function validateState(value) {
+	if (!isValidState(value)) throw new Error("Invalid persistence state.");
+	return value;
+}
+//#endregion
+//#region src/server/storage.ts
+/**
+* In-memory storage engine and filesystem persistence for S3 emulator.
+*/
+function writeAll(fd, bytes) {
+	let offset = 0;
+	while (offset < bytes.length) {
+		const written = writeSync(fd, bytes, offset, bytes.length - offset, offset);
+		if (written === 0) throw new Error("Persistence write made no progress.");
+		offset += written;
+	}
+}
+var S3Storage = class {
+	dataDir;
+	persist;
+	committedState;
+	buckets = new AccountScopedMap();
+	bucketVersioning = new AccountScopedMap();
+	bucketLifecycle = new AccountScopedMap();
+	bucketCors = new AccountScopedMap();
+	objectVersions = new AccountScopedMap();
+	multipartUploads = new AccountScopedMap();
+	completedMultipartUploads = new AccountScopedMap();
+	constructor(options = {}) {
+		this.dataDir = options.dataDir || process.env.S3_DATA_DIR || "/tmp/emulator/s3";
+		this.persist = options.persist ?? process.env.S3_PERSIST === "1";
+		if (this.persist) this.loadPersistedData();
+	}
+	objectDiskPath(bucket, key, accountId) {
+		return join(this.bucketDiskPath(bucket, accountId), createHash("sha256").update(key).digest("hex"), "body");
+	}
+	bucketDiskPath(bucket, accountId = getAccountId()) {
+		const digest = createHash("sha256").update(JSON.stringify([accountId, bucket])).digest("hex");
+		return join(this.dataDir, "buckets", digest);
+	}
+	versionDiskPath(bucket, key, versionId, accountId) {
+		const basePath = this.objectDiskPath(bucket, key, accountId);
+		return join(dirname(basePath), "versions", createHash("sha256").update(versionId).digest("hex"));
+	}
+	syncDirectory(directory) {
+		if (process.platform === "win32") return;
+		const fd = openSync(directory, "r");
+		try {
+			fsyncSync(fd);
+		} finally {
+			closeSync(fd);
+		}
+	}
+	atomicWrite(filePath, data) {
+		const tmp = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+		const dir = dirname(filePath);
+		const missing = [];
+		for (let current = dir; !existsSync(current); current = dirname(current)) missing.push(current);
+		mkdirSync(dir, {
+			recursive: true,
+			mode: 448
+		});
+		for (const created of missing.toReversed()) this.syncDirectory(dirname(created));
+		try {
+			const fd = openSync(tmp, "wx", 384);
+			try {
+				writeAll(fd, Buffer.isBuffer(data) ? data : Buffer.from(data, "utf-8"));
+				fsyncSync(fd);
+			} finally {
+				closeSync(fd);
+			}
+			renameSync(tmp, filePath);
+			this.syncDirectory(dir);
+		} catch (error) {
+			if (existsSync(tmp)) unlinkSync(tmp);
+			throw error;
+		}
+	}
+	blobPath(reference) {
+		return join(this.dataDir, "blobs", reference);
+	}
+	persistBody(body) {
+		const reference = createHash("sha256").update(body).digest("hex");
+		const path = this.blobPath(reference);
+		if (existsSync(path)) this.syncDirectory(dirname(path));
+		else this.atomicWrite(path, body);
+		return reference;
+	}
+	readBody(bucketName, key, obj) {
+		if (obj?.body !== null && obj?.body !== void 0) return obj.body;
+		if (!this.persist) return Buffer.alloc(0);
+		if (obj?.bodyRef) {
+			if (!existsSync(this.blobPath(obj.bodyRef))) throw new Error(`Persisted object body not found for key: ${key}`);
+			return readFileSync(this.blobPath(obj.bodyRef));
+		}
+		if (obj?.versionId) {
+			const vpath = this.versionDiskPath(bucketName, key, obj.versionId);
+			return readFileSync(vpath);
+		}
+		const fpath = this.objectDiskPath(bucketName, key);
+		if (!existsSync(fpath)) throw new Error(`Persisted object body not found for key: ${key}`);
+		return readFileSync(fpath);
+	}
+	readVersionBody(bucketName, key, v) {
+		if (v.data !== null && v.data !== void 0) return v.data;
+		if (!this.persist) return Buffer.alloc(0);
+		if (v.bodyRef) return readFileSync(this.blobPath(v.bodyRef));
+		const vpath = this.versionDiskPath(bucketName, key, v.versionId);
+		if (existsSync(vpath)) return readFileSync(vpath);
+		throw new Error(`Persisted version body not found for key: ${key}, version: ${v.versionId}`);
+	}
+	deletePersistedObject(_bucketName, _key) {}
+	/** Commit immutable body references before releasing any in-memory content. */
+	persistState() {
+		if (!this.persist) return;
+		try {
+			const state = this.getState();
+			for (const [scopedKey, bucket] of this.buckets._data) {
+				const separator = scopedKey.indexOf("::");
+				const accountId = scopedKey.slice(0, separator);
+				const bucketName = scopedKey.slice(separator + 2);
+				withAccountContext({ accountId }, () => {
+					for (const [key, obj] of Object.entries(bucket.objects)) state.buckets_meta[scopedKey].objects[key].bodyRef = obj.bodyRef && obj.body === null ? obj.bodyRef : this.persistBody(this.readBody(bucketName, key, obj));
+					for (const [[name, key], versions] of this.objectVersions.entries()) {
+						if (name !== bucketName) continue;
+						const stored = state.object_versions?.[`${accountId}::${JSON.stringify([name, key])}`];
+						if (!stored) throw new Error("Missing version snapshot.");
+						for (const [index, version] of versions.entries()) {
+							if (version.isDeleteMarker) continue;
+							stored[index].bodyRef = version.bodyRef && (version.data === null || version.data === void 0) ? version.bodyRef : this.persistBody(this.readVersionBody(name, key, version));
+							stored[index].data = null;
+						}
+					}
+				});
+			}
+			validateState(state);
+			this.atomicWrite(join(this.dataDir, ".config", "state.json"), JSON.stringify(state));
+			this.committedState = state;
+			this.replaceState(state);
+		} catch (error) {
+			this.clearState();
+			this.completedMultipartUploads._data.clear();
+			this.loadPersistedData(false);
+			throw error;
+		}
+	}
+	clearState() {
+		this.buckets._data.clear();
+		this.bucketVersioning._data.clear();
+		this.bucketLifecycle._data.clear();
+		this.bucketCors._data.clear();
+		this.objectVersions._data.clear();
+	}
+	replaceState(state) {
+		this.clearState();
+		this.restoreState(structuredClone(state));
+	}
+	loadPersistedData(reclaim = true) {
+		const manifest = join(this.dataDir, ".config", "state.json");
+		if (!existsSync(manifest)) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(readFileSync(manifest, "utf-8"));
+		} catch {
+			throw new Error("Corrupted persistence state manifest: invalid JSON.");
+		}
+		const state = validateState(parsed);
+		this.committedState = state;
+		this.replaceState(state);
+		if (reclaim) this.reclaimBlobs();
+	}
+	reclaimBlobs() {
+		const directory = join(this.dataDir, "blobs");
+		if (!existsSync(directory) || !this.committedState) return;
+		const references = /* @__PURE__ */ new Set();
+		for (const bucket of Object.values(this.committedState.buckets_meta)) for (const object of Object.values(bucket.objects)) if (object.bodyRef) references.add(object.bodyRef);
+		for (const versions of Object.values(this.committedState.object_versions ?? {})) for (const version of versions) if (version.bodyRef) references.add(version.bodyRef);
+		for (const reference of references) if (!existsSync(this.blobPath(reference))) throw new Error("Persisted object body not found.");
+		for (const name of readdirSync(directory)) if (!references.has(name)) unlinkSync(join(directory, name));
+	}
+	getState() {
+		const bucketsMeta = {};
+		for (const [scopedKey, bkt] of this.buckets._data.entries()) {
+			const objectsMeta = Object.create(null);
+			for (const [k, obj] of Object.entries(bkt.objects)) objectsMeta[k] = {
+				...obj,
+				body: null
+			};
+			const { objects: _objects, ...meta } = bkt;
+			bucketsMeta[scopedKey] = {
+				...meta,
+				objects: objectsMeta
+			};
+		}
+		return {
+			version: 2,
+			buckets_meta: bucketsMeta,
+			bucket_versioning: Object.fromEntries(this.bucketVersioning._data),
+			bucket_lifecycle: Object.fromEntries(this.bucketLifecycle._data),
+			bucket_cors: Object.fromEntries(this.bucketCors._data),
+			object_versions: structuredClone(Object.fromEntries(this.objectVersions._data))
+		};
+	}
+	restoreState(state) {
+		if (!state) return;
+		if (state.buckets_meta) {
+			if (typeof state.buckets_meta !== "object" || state.buckets_meta === null) throw new Error("Corrupted persistence state manifest: invalid buckets_meta.");
+			for (const [scopedKey, meta] of Object.entries(state.buckets_meta)) if (!this.buckets._data.has(scopedKey)) {
+				const objects = meta.objects || {};
+				this.buckets._data.set(scopedKey, {
+					...meta,
+					objects: Object.assign(Object.create(null), objects)
+				});
+			}
+		}
+		const importMap = (map, data) => {
+			if (!data) return;
+			for (const [k, v] of Object.entries(data)) map._data.set(k, v);
+		};
+		importMap(this.bucketVersioning, state.bucket_versioning);
+		importMap(this.bucketLifecycle, state.bucket_lifecycle);
+		importMap(this.bucketCors, state.bucket_cors);
+		importMap(this.objectVersions, state.object_versions);
+	}
+};
+//#endregion
+//#region src/server/service.ts
+/**
+* Core S3 Service Emulator implementation.
+*/
+const PRESERVED_HEADERS = [
+	"cache-control",
+	"content-disposition",
+	"content-language",
+	"expires"
+];
+const RESPONSE_OVERRIDE_PARAMS = [
+	"response-cache-control",
+	"response-content-disposition",
+	"response-content-encoding",
+	"response-content-language",
+	"response-content-type",
+	"response-expires"
+];
+var S3Service = class {
+	storage;
+	constructor(options = {}) {
+		this.storage = new S3Storage(options);
+	}
+	canonicalOwnerId() {
+		return createHash("sha256").update(getAccountId()).digest("hex");
+	}
+	extractUserMetadata(headers) {
+		const meta = {};
+		for (const [k, v] of Object.entries(headers)) if (k.toLowerCase().startsWith("x-amz-meta-")) meta[k] = v;
+		return meta;
+	}
+	buildObjectRecord(body, headers, etag, checksums) {
+		const contentType = headers["content-type"] || "application/octet-stream";
+		const contentEncoding = headers["content-encoding"];
+		const preserved = {};
+		for (const h of PRESERVED_HEADERS) if (headers[h] !== void 0) preserved[h] = headers[h];
+		return {
+			body,
+			contentType,
+			contentEncoding,
+			etag: etag || `"${md5Hex(body)}"`,
+			lastModified: nowIso(),
+			size: body.length,
+			metadata: this.extractUserMetadata(headers),
+			preservedHeaders: preserved,
+			checksums: checksums || {}
+		};
+	}
+	parseRange(rangeHeader, total) {
+		const m = rangeHeader.match(/^bytes=(\d*)-(\d*)$/u);
+		if (!m) return null;
+		const s = m[1];
+		const e = m[2];
+		if (s === "" && e === "") return null;
+		if (s === "") {
+			const suffix = Math.trunc(Number(e));
+			if (Number.isNaN(suffix) || suffix === 0) return null;
+			return [Math.max(0, total - suffix), total - 1];
+		}
+		const start = Math.trunc(Number(s));
+		if (Number.isNaN(start) || start >= total) return null;
+		const end = e === "" ? total - 1 : Math.min(Math.trunc(Number(e)), total - 1);
+		if (Number.isNaN(end) || start > end) return null;
+		return [start, end];
+	}
+	applyResponseOverrides(respHeaders, queryParams) {
+		for (const [qkey, hkey] of [
+			["response-cache-control", "Cache-Control"],
+			["response-content-disposition", "Content-Disposition"],
+			["response-content-encoding", "Content-Encoding"],
+			["response-content-language", "Content-Language"],
+			["response-content-type", "Content-Type"],
+			["response-expires", "Expires"]
+		]) {
+			const val = qp(queryParams, qkey);
+			if (!val) continue;
+			const targetLc = hkey.toLowerCase();
+			for (const existing of Object.keys(respHeaders)) if (existing.toLowerCase() === targetLc) delete respHeaders[existing];
+			respHeaders[hkey] = val;
+		}
+	}
+	rejectResponseOverridesIfUnsigned(headers, queryParams, bucketName, key) {
+		if (!RESPONSE_OVERRIDE_PARAMS.some((p) => Boolean(qp(queryParams, p)))) return null;
+		if (headers["authorization"]) return null;
+		if (qp(queryParams, "X-Amz-Signature") || qp(queryParams, "x-amz-signature") || qp(queryParams, "X-Amz-Algorithm") || qp(queryParams, "x-amz-algorithm")) return null;
+		return s3Error("InvalidRequest", "Request specific response headers cannot be used for anonymous GET requests.", 400, `/${bucketName}/${key}`);
+	}
+	checkPutPreconditions(headers, existingObj) {
+		const ifNoneMatch = (headers["if-none-match"] || "").trim();
+		const ifMatch = (headers["if-match"] || "").trim();
+		if (!ifNoneMatch && !ifMatch) return null;
+		const existingEtag = existingObj ? existingObj.etag.replaceAll(/^"|"$/gu, "") : null;
+		if (ifNoneMatch) {
+			if (ifNoneMatch === "*") {
+				if (existingObj !== void 0) return preconditionFailed();
+			} else if (existingObj !== void 0 && ifNoneMatch.replaceAll(/^"|"$/gu, "") === existingEtag) return preconditionFailed();
+		}
+		if (ifMatch) {
+			if (existingObj === void 0) return s3Error("NoSuchKey", "The specified key does not exist.", 404);
+			if (ifMatch !== "*" && ifMatch.replaceAll(/^"|"$/gu, "") !== existingEtag) return preconditionFailed();
+		}
+		return null;
+	}
+	etagConditionMatches(fieldValue, etag) {
+		if (fieldValue === "*") return true;
+		for (let candidate of fieldValue.split(",")) {
+			candidate = candidate.trim();
+			if (candidate.toUpperCase().startsWith("W/")) candidate = candidate.slice(2);
+			if (candidate.replaceAll(/^"|"$/gu, "") === etag) return true;
+		}
+		return false;
+	}
+	checkReadPreconditions(headers, obj, respHeaders) {
+		const etag = (obj.etag || "").replaceAll(/^"|"$/gu, "");
+		const mtime = parseHttpDate(obj.lastModified);
+		const ifMatch = (headers["if-match"] || "").trim();
+		if (ifMatch) {
+			if (!this.etagConditionMatches(ifMatch, etag)) return preconditionFailed();
+		} else {
+			const unmod = parseHttpDate(headers["if-unmodified-since"]);
+			if (unmod && mtime && mtime.getTime() > unmod.getTime()) return preconditionFailed();
+		}
+		const ifNoneMatch = (headers["if-none-match"] || "").trim();
+		if (ifNoneMatch) {
+			if (this.etagConditionMatches(ifNoneMatch, etag)) return notModified(respHeaders);
+		} else {
+			const mod = parseHttpDate(headers["if-modified-since"]);
+			if (mod && mtime && mtime.getTime() <= mod.getTime()) return notModified(respHeaders);
+		}
+		return null;
+	}
+	objectResponseHeaders(obj, includeChecksums = false) {
+		const h = {};
+		h["Content-Type"] = obj.contentType;
+		h["ETag"] = obj.etag;
+		h["Last-Modified"] = isoToRfc7231(obj.lastModified);
+		h["Content-Length"] = String(obj.size);
+		h["Accept-Ranges"] = "bytes";
+		if (obj.contentEncoding) h["Content-Encoding"] = obj.contentEncoding;
+		for (const [k, val] of Object.entries(obj.preservedHeaders || {})) h[k] = val;
+		Object.assign(h, obj.metadata || {});
+		if (obj.versionId) h["x-amz-version-id"] = obj.versionId;
+		if (includeChecksums) {
+			const stored = obj.checksums || {};
+			for (const [alg, val] of Object.entries(stored)) h[`x-amz-checksum-${alg.toLowerCase()}`] = val;
+			if (Object.keys(stored).length > 0) h["x-amz-checksum-type"] = obj.checksumType || "FULL_OBJECT";
+		}
+		return h;
+	}
+	recordObjectVersion(bucketName, key, priorObj, obj, data) {
+		const versioning = this.storage.bucketVersioning.get(bucketName);
+		if (versioning !== "Enabled" && versioning !== "Suspended") return null;
+		const vkey = [bucketName, key];
+		let versions = this.storage.objectVersions.get(vkey);
+		if (!versions) {
+			versions = [];
+			this.storage.objectVersions.set(vkey, versions);
+		}
+		let versionId;
+		if (versioning === "Enabled") {
+			if (priorObj && !priorObj.versionId && !versions.some((v) => v.versionId === "null")) versions.push({
+				versionId: "null",
+				lastModified: priorObj.lastModified,
+				etag: priorObj.etag,
+				size: priorObj.size,
+				isLatest: false,
+				data: this.storage.readBody(bucketName, key, priorObj),
+				contentType: priorObj.contentType,
+				contentEncoding: priorObj.contentEncoding,
+				metadata: priorObj.metadata,
+				preservedHeaders: priorObj.preservedHeaders,
+				checksums: priorObj.checksums,
+				checksumType: priorObj.checksumType
+			});
+			versionId = newUuid();
+			obj.versionId = versionId;
+		} else {
+			versionId = "null";
+			const filtered = versions.filter((v) => v.versionId !== "null");
+			versions.length = 0;
+			versions.push(...filtered);
+		}
+		for (const v of versions) v.isLatest = false;
+		versions.push({
+			versionId,
+			lastModified: obj.lastModified,
+			etag: obj.etag,
+			size: obj.size,
+			isLatest: true,
+			data,
+			contentType: obj.contentType,
+			contentEncoding: obj.contentEncoding,
+			metadata: obj.metadata,
+			preservedHeaders: obj.preservedHeaders,
+			checksums: obj.checksums,
+			checksumType: obj.checksumType
+		});
+		return versioning === "Enabled" ? versionId : null;
+	}
+	recordDeleteMarker(bucketName, key, priorObj) {
+		const vkey = [bucketName, key];
+		let versions = this.storage.objectVersions.get(vkey);
+		if (!versions) {
+			versions = [];
+			this.storage.objectVersions.set(vkey, versions);
+		}
+		const versioning = this.storage.bucketVersioning.get(bucketName);
+		let markerId;
+		if (versioning === "Enabled") {
+			if (priorObj && !priorObj.versionId && !versions.some((v) => v.versionId === "null")) versions.push({
+				versionId: "null",
+				lastModified: priorObj.lastModified,
+				etag: priorObj.etag,
+				size: priorObj.size,
+				isLatest: false,
+				data: this.storage.readBody(bucketName, key, priorObj),
+				contentType: priorObj.contentType,
+				contentEncoding: priorObj.contentEncoding,
+				metadata: priorObj.metadata,
+				preservedHeaders: priorObj.preservedHeaders,
+				checksums: priorObj.checksums,
+				checksumType: priorObj.checksumType
+			});
+			markerId = newUuid();
+		} else {
+			markerId = "null";
+			const filtered = versions.filter((v) => v.versionId !== "null");
+			versions.length = 0;
+			versions.push(...filtered);
+		}
+		for (const v of versions) v.isLatest = false;
+		versions.push({
+			versionId: markerId,
+			lastModified: nowIso(),
+			etag: "",
+			size: 0,
+			isLatest: true,
+			isDeleteMarker: true
+		});
+		return markerId;
+	}
+	objectRecordFromVersion(v) {
+		return {
+			body: v.data ?? null,
+			bodyRef: v.bodyRef,
+			contentType: v.contentType || "application/octet-stream",
+			contentEncoding: v.contentEncoding,
+			etag: v.etag,
+			lastModified: v.lastModified,
+			size: v.size,
+			metadata: v.metadata || {},
+			preservedHeaders: v.preservedHeaders || {},
+			checksums: v.checksums || {},
+			checksumType: v.checksumType,
+			versionId: v.versionId
+		};
+	}
+	deleteMarkerReadRefused(version) {
+		const [status, headers, body] = s3Error("MethodNotAllowed", "The specified method is not allowed against this resource.", 405);
+		headers["x-amz-delete-marker"] = "true";
+		headers["x-amz-version-id"] = version.versionId;
+		if (version.lastModified) headers["Last-Modified"] = isoToRfc7231(version.lastModified);
+		return [
+			status,
+			headers,
+			body
+		];
+	}
+	deleteMarker404Headers(bucketName, key) {
+		const versions = this.storage.objectVersions.get([bucketName, key]);
+		if (!versions || versions.length === 0) return {};
+		const latest = versions.at(-1);
+		if (latest && latest.isDeleteMarker && latest.isLatest) return {
+			"x-amz-delete-marker": "true",
+			"x-amz-version-id": latest.versionId
+		};
+		return {};
+	}
+	deleteObjectVersion(bucket, bucketName, key, versionId) {
+		const vkey = [bucketName, key];
+		const versions = this.storage.objectVersions.get(vkey);
+		if (!versions || versions.length === 0) {
+			if (versionId === "null" && bucket.objects[key] && !bucket.objects[key].versionId) {
+				this.purgeCurrentObject(bucketName, key, bucket);
+				return [true, false];
+			}
+			return [false, false];
+		}
+		const idx = versions.findIndex((v) => v.versionId === versionId);
+		if (idx === -1) {
+			if (versionId === "null" && bucket.objects[key] && !bucket.objects[key].versionId) {
+				this.purgeCurrentObject(bucketName, key, bucket);
+				return [true, false];
+			}
+			return [false, false];
+		}
+		const removed = versions.splice(idx, 1)[0];
+		const wasMarker = Boolean(removed.isDeleteMarker);
+		if (versions.length === 0) {
+			this.storage.objectVersions.delete(vkey);
+			this.purgeCurrentObject(bucketName, key, bucket);
+			return [true, wasMarker];
+		}
+		for (const v of versions) v.isLatest = false;
+		const latest = versions.at(-1);
+		if (latest) {
+			latest.isLatest = true;
+			if (latest.isDeleteMarker) delete bucket.objects[key];
+			else bucket.objects[key] = this.objectRecordFromVersion(latest);
+		}
+		return [true, wasMarker];
+	}
+	purgeCurrentObject(bucketName, key, bucket) {
+		delete bucket.objects[key];
+		this.storage.deletePersistedObject(bucketName, key);
+	}
+	parseBucketKey(path) {
+		const trimmed = path.replace(/^\/+/u, "");
+		const slashIdx = trimmed.indexOf("/");
+		if (slashIdx === -1) return [trimmed, ""];
+		return [trimmed.slice(0, slashIdx), trimmed.slice(slashIdx + 1)];
+	}
+	handleRequest(method, path, headers, body, queryParams, signedPath) {
+		const [bucket, key] = this.parseBucketKey(path);
+		if (method === "OPTIONS") {
+			this.ensureBucket(bucket);
+			const corsHeaders = corsResponseHeaders(this.storage.bucketCors.get(bucket), method, headers);
+			if (!this.storage.buckets.has(bucket)) return noSuchBucket(bucket);
+			if (!corsHeaders) return s3Error("AccessDenied", "CORS request is not allowed.", 403);
+			return [
+				200,
+				corsHeaders,
+				Buffer.alloc(0)
+			];
+		}
+		const sigError = verifyPresignedSigV4(method, signedPath === void 0 ? path : signedPath, headers, queryParams);
+		if (sigError) {
+			const [status, respHeaders, respBody] = sigError;
+			const corsHeaders = corsResponseHeaders(this.storage.bucketCors.get(bucket) ?? `<CORSConfiguration><CORSRule><AllowedOrigin>*</AllowedOrigin><AllowedMethod>GET</AllowedMethod><AllowedMethod>PUT</AllowedMethod><AllowedMethod>POST</AllowedMethod><AllowedMethod>DELETE</AllowedMethod><AllowedMethod>HEAD</AllowedMethod><AllowedHeader>*</AllowedHeader><ExposeHeader>ETag</ExposeHeader><MaxAgeSeconds>3000</MaxAgeSeconds></CORSRule></CORSConfiguration>`, method, headers);
+			Object.assign(respHeaders, corsHeaders);
+			respHeaders["x-amz-request-id"] = respHeaders["x-amz-request-id"] || newUuid();
+			respHeaders["x-amz-id-2"] = respHeaders["x-amz-id-2"] || createHash("sha256").update(newUuid()).digest("base64");
+			return [
+				status,
+				respHeaders,
+				respBody
+			];
+		}
+		this.ensureBucket(bucket);
+		const corsHeaders = corsResponseHeaders(this.storage.bucketCors.get(bucket), method, headers);
+		const mergedHeaders = mergeHoistedAmzHeaders(headers, queryParams);
+		this.expireMultipartUploads(bucket);
+		const [status, respHeaders, respBody] = this.dispatch(method, bucket, key, mergedHeaders, body, queryParams);
+		Object.assign(respHeaders, corsHeaders);
+		if (method !== "GET" && method !== "HEAD" && status >= 200 && status < 300) this.storage.persistState();
+		respHeaders["x-amz-request-id"] = respHeaders["x-amz-request-id"] || newUuid();
+		respHeaders["x-amz-id-2"] = respHeaders["x-amz-id-2"] || createHash("sha256").update(newUuid()).digest("base64");
+		if (method === "HEAD") return [
+			status,
+			respHeaders,
+			Buffer.alloc(0)
+		];
+		return [
+			status,
+			respHeaders,
+			respBody
+		];
+	}
+	dispatch(method, bucket, key, headers, body, queryParams) {
+		const unsupported = () => s3Error("NotImplemented", "This operation is not supported by the FileBucket emulator.", 501);
+		const selectors = Object.keys(queryParams).filter((name) => !name.toLowerCase().startsWith("x-amz-") && ![
+			"x-id",
+			"accountId",
+			"region"
+		].includes(name));
+		const accepts = (...names) => selectors.every((name) => names.includes(name));
+		if (Object.keys(headers).some((name) => name === "x-amz-acl" || name.startsWith("x-amz-grant-") || name.startsWith("x-amz-server-side-encryption") || name.startsWith("x-amz-copy-source-server-side-encryption") || name.startsWith("x-amz-object-lock-") || name === "x-amz-bucket-object-lock-enabled" || name.startsWith("x-amz-tagging") || name === "x-amz-website-redirect-location" || name === "x-amz-storage-class")) return unsupported();
+		if (!bucket) return unsupported();
+		if (key) {
+			if (method === "GET" && accepts("versionId", ...RESPONSE_OVERRIDE_PARAMS)) return this.getObject(bucket, key, headers, queryParams);
+			if (method === "PUT") {
+				if ("uploadId" in queryParams && "partNumber" in queryParams && accepts("uploadId", "partNumber") && !("x-amz-copy-source" in headers)) return this.uploadPart(bucket, key, body, queryParams, headers);
+				if (accepts()) return "x-amz-copy-source" in headers ? this.copyObject(bucket, key, headers) : this.putObject(bucket, key, body, headers);
+			}
+			if (method === "POST") {
+				if ("uploads" in queryParams && accepts("uploads")) return this.createMultipartUpload(bucket, key, headers);
+				if ("uploadId" in queryParams && accepts("uploadId")) return this.completeMultipartUpload(bucket, key, body, queryParams, headers);
+			}
+			if (method === "DELETE") {
+				if ("uploadId" in queryParams && accepts("uploadId")) return this.abortMultipartUpload(bucket, key, queryParams);
+				if (accepts("versionId")) return this.deleteObject(bucket, key, headers, queryParams);
+			}
+		} else {
+			if (method === "HEAD" && accepts()) return [
+				200,
+				{},
+				Buffer.alloc(0)
+			];
+			if (method === "PUT") {
+				if ("versioning" in queryParams && accepts("versioning")) return this.putBucketVersioning(bucket, body);
+				if ("cors" in queryParams && accepts("cors")) return this.putBucketCors(bucket, body);
+				if ("lifecycle" in queryParams && accepts("lifecycle")) return this.putBucketLifecycle(bucket, body);
+			}
+			if (method === "GET") {
+				if (qp(queryParams, "list-type") === "2" && accepts("list-type", "prefix", "delimiter", "max-keys", "continuation-token", "start-after", "encoding-type", "fetch-owner")) return this.listObjectsV2(bucket, queryParams);
+				if ("versions" in queryParams && accepts("versions", "prefix", "delimiter", "max-keys", "key-marker", "version-id-marker", "encoding-type")) return this.listObjectVersions(bucket, queryParams);
+			}
+			if (method === "POST" && "delete" in queryParams && accepts("delete")) return this.deleteObjects(bucket, body);
+		}
+		return unsupported();
+	}
+	ensureBucket(name) {
+		if (!name) return;
+		let changed = false;
+		if (!this.storage.buckets.has(name)) {
+			this.storage.buckets.set(name, {
+				created: nowIso(),
+				objects: Object.create(null),
+				region: getRegion()
+			});
+			changed = true;
+		}
+		if (!this.storage.bucketCors.has(name)) {
+			this.storage.bucketCors.set(name, `<CORSConfiguration><CORSRule><AllowedOrigin>*</AllowedOrigin><AllowedMethod>GET</AllowedMethod><AllowedMethod>PUT</AllowedMethod><AllowedMethod>POST</AllowedMethod><AllowedMethod>DELETE</AllowedMethod><AllowedMethod>HEAD</AllowedMethod><AllowedHeader>*</AllowedHeader><ExposeHeader>ETag</ExposeHeader><MaxAgeSeconds>3000</MaxAgeSeconds></CORSRule></CORSConfiguration>`);
+			changed = true;
+		}
+		if (changed) this.storage.persistState();
+	}
+	putBucketVersioning(name, body) {
+		if (!this.storage.buckets.has(name)) return noSuchBucket(name);
+		try {
+			const statusEl = parseXml(body).find("Status");
+			if (statusEl?.text) this.storage.bucketVersioning.set(name, statusEl.text.trim());
+		} catch {}
+		return [
+			200,
+			{},
+			Buffer.alloc(0)
+		];
+	}
+	putBucketLifecycle(name, body) {
+		if (!this.storage.buckets.has(name)) return noSuchBucket(name);
+		try {
+			const rules = parseLifecycleXml(body);
+			this.storage.bucketLifecycle.set(name, rules);
+		} catch {
+			return s3Error("MalformedXML", "Invalid lifecycle configuration.", 400);
+		}
+		return [
+			200,
+			{ "x-amz-transition-default-minimum-object-size": "all_storage_classes_128K" },
+			Buffer.alloc(0)
+		];
+	}
+	putBucketCors(name, body) {
+		if (!this.storage.buckets.has(name)) return noSuchBucket(name);
+		this.storage.bucketCors.set(name, body.toString("utf-8"));
+		return [
+			200,
+			{},
+			Buffer.alloc(0)
+		];
+	}
+	putObject(bucketName, key, body, headers) {
+		const bucket = this.storage.buckets.get(bucketName);
+		if (!bucket) return noSuchBucket(bucketName);
+		const md5Err = validateContentMd5(headers, body);
+		if (md5Err) return md5Err;
+		const existingObj = bucket.objects[key];
+		const precondErr = this.checkPutPreconditions(headers, existingObj);
+		if (precondErr) return precondErr;
+		const { checksums, error: csumErr } = resolveObjectChecksums(body, headers);
+		if (csumErr) return csumErr;
+		const etag = `"${md5Hex(body)}"`;
+		const obj = this.buildObjectRecord(body, headers, etag, checksums);
+		const priorObj = bucket.objects[key];
+		bucket.objects[key] = obj;
+		const respHeaders = {};
+		respHeaders["ETag"] = obj.etag;
+		respHeaders["Content-Length"] = "0";
+		const versionId = this.recordObjectVersion(bucketName, key, priorObj, obj, body);
+		if (versionId) respHeaders["x-amz-version-id"] = versionId;
+		return [
+			200,
+			respHeaders,
+			Buffer.alloc(0)
+		];
+	}
+	getObject(bucketName, key, headers, queryParams) {
+		const bucket = this.storage.buckets.get(bucketName);
+		if (!bucket) return noSuchBucket(bucketName);
+		const unsignedErr = this.rejectResponseOverridesIfUnsigned(headers, queryParams, bucketName, key);
+		if (unsignedErr) return unsignedErr;
+		const versionId = qp(queryParams, "versionId");
+		let obj = bucket.objects[key];
+		let version;
+		if (versionId) {
+			version = this.storage.objectVersions.get([bucketName, key])?.find((entry) => entry.versionId === versionId);
+			if (version?.isDeleteMarker) return this.deleteMarkerReadRefused(version);
+			if (version) obj = this.objectRecordFromVersion(version);
+			else if (versionId !== "null" || !obj || obj.versionId) return noSuchVersion(bucketName, key);
+		}
+		if (!obj) return noSuchKey(bucketName, key, this.deleteMarker404Headers(bucketName, key));
+		const rangeHeader = headers["range"] || "";
+		const respHeaders = this.objectResponseHeaders(obj, headers["x-amz-checksum-mode"]?.toUpperCase() === "ENABLED" && !rangeHeader);
+		const precond = this.checkReadPreconditions(headers, obj, respHeaders);
+		if (precond) return precond;
+		const body = version ? this.storage.readVersionBody(bucketName, key, version) : this.storage.readBody(bucketName, key, obj);
+		this.applyResponseOverrides(respHeaders, queryParams);
+		if (rangeHeader) {
+			const range = obj.size > 0 ? this.parseRange(rangeHeader, obj.size) : null;
+			if (!range) return invalidRange(bucketName, key, obj.size);
+			const [start, end] = range;
+			const slice = body.subarray(start, end + 1);
+			respHeaders["Content-Length"] = String(slice.length);
+			respHeaders["Content-Range"] = `bytes ${start}-${end}/${obj.size}`;
+			return [
+				206,
+				respHeaders,
+				slice
+			];
+		}
+		return [
+			200,
+			respHeaders,
+			body
+		];
+	}
+	deleteObject(bucketName, key, headers = {}, queryParams = {}) {
+		const bucket = this.storage.buckets.get(bucketName);
+		if (!bucket) return noSuchBucket(bucketName);
+		if (headers["x-amz-if-match-size"] || headers["x-amz-if-match-last-modified-time"]) return s3Error("NotImplemented", "A header you provided implies functionality that is not implemented", 501, `/${bucketName}/${key}`);
+		const ifMatch = (headers["if-match"] || "").trim();
+		if (ifMatch) {
+			const cur = bucket.objects[key];
+			if (!cur) return s3Error("NoSuchKey", "The specified key does not exist.", 404, `/${bucketName}/${key}`);
+			if (ifMatch !== "*" && ifMatch.replaceAll(/^"|"$/gu, "") !== cur.etag.replaceAll(/^"|"$/gu, "")) return preconditionFailed(void 0, `/${bucketName}/${key}`);
+		}
+		const versionId = qp(queryParams, "versionId");
+		if (versionId) {
+			const [, wasDeleteMarker] = this.deleteObjectVersion(bucket, bucketName, key, versionId);
+			const respHeaders = {};
+			respHeaders["x-amz-version-id"] = versionId;
+			if (wasDeleteMarker) respHeaders["x-amz-delete-marker"] = "true";
+			return [
+				204,
+				respHeaders,
+				Buffer.alloc(0)
+			];
+		}
+		const versioning = this.storage.bucketVersioning.get(bucketName);
+		if (versioning === "Enabled" || versioning === "Suspended") {
+			const deleteMarkerId = this.recordDeleteMarker(bucketName, key, bucket.objects[key]);
+			delete bucket.objects[key];
+			return [
+				204,
+				{
+					"x-amz-delete-marker": "true",
+					"x-amz-version-id": deleteMarkerId
+				},
+				Buffer.alloc(0)
+			];
+		}
+		delete bucket.objects[key];
+		this.storage.deletePersistedObject(bucketName, key);
+		return [
+			204,
+			{},
+			Buffer.alloc(0)
+		];
+	}
+	deleteObjects(bucketName, body) {
+		const bucket = this.storage.buckets.get(bucketName);
+		if (!bucket) return noSuchBucket(bucketName);
+		let root;
+		try {
+			root = parseXml(body);
+		} catch {
+			return s3Error("MalformedXML", "The XML you provided was not well-formed", 400);
+		}
+		const quiet = (root.findText("Quiet") || "").toLowerCase() === "true";
+		const deleted = [];
+		const errors = [];
+		for (const objEl of root.findAll("Object")) {
+			const k = objEl.findText("Key");
+			if (!k) continue;
+			const versionId = objEl.findText("VersionId") || "";
+			if (objEl.findText("Size") || objEl.findText("LastModifiedTime")) {
+				errors.push({
+					key: k,
+					versionId,
+					code: "NotImplemented",
+					msg: "A header you provided implies functionality that is not implemented"
+				});
+				continue;
+			}
+			const condEtag = objEl.findText("ETag");
+			if (condEtag) {
+				const cur = bucket.objects[k];
+				if (!cur) {
+					errors.push({
+						key: k,
+						versionId,
+						code: "NoSuchKey",
+						msg: "The specified key does not exist."
+					});
+					continue;
+				}
+				if (condEtag !== "*" && condEtag.replaceAll(/^"|"$/gu, "") !== cur.etag.replaceAll(/^"|"$/gu, "")) {
+					errors.push({
+						key: k,
+						versionId,
+						code: "PreconditionFailed",
+						msg: "At least one of the preconditions you specified did not hold."
+					});
+					continue;
+				}
+			}
+			if (versionId) {
+				const [, wasMarker] = this.deleteObjectVersion(bucket, bucketName, k, versionId);
+				deleted.push({
+					key: k,
+					versionId,
+					wasMarker
+				});
+			} else if (this.storage.bucketVersioning.get(bucketName) === "Enabled" || this.storage.bucketVersioning.get(bucketName) === "Suspended") {
+				const markerId = this.recordDeleteMarker(bucketName, k, bucket.objects[k]);
+				delete bucket.objects[k];
+				deleted.push({
+					key: k,
+					versionId: "",
+					wasMarker: false,
+					markerCreated: markerId
+				});
+			} else {
+				delete bucket.objects[k];
+				this.storage.deletePersistedObject(bucketName, k);
+				deleted.push({
+					key: k,
+					versionId: "",
+					wasMarker: false
+				});
+			}
+		}
+		const resp = new XmlElement("DeleteResult", { xmlns: S3_NS });
+		if (!quiet) for (const d of deleted) {
+			const el = resp.subElement("Deleted");
+			el.subElement("Key", d.key);
+			if (d.versionId) {
+				el.subElement("VersionId", d.versionId);
+				if (d.wasMarker) {
+					el.subElement("DeleteMarker", "true");
+					el.subElement("DeleteMarkerVersionId", d.versionId);
+				}
+			} else if (d.markerCreated) {
+				el.subElement("DeleteMarker", "true");
+				el.subElement("DeleteMarkerVersionId", d.markerCreated);
+			}
+		}
+		for (const e of errors) {
+			const el = resp.subElement("Error");
+			el.subElement("Key", e.key);
+			if (e.versionId) el.subElement("VersionId", e.versionId);
+			el.subElement("Code", e.code);
+			el.subElement("Message", e.msg);
+		}
+		return [
+			200,
+			{ "Content-Type": "application/xml" },
+			xmlBody(resp)
+		];
+	}
+	copyObject(destBucketName, destKey, headers) {
+		const [rawPath, srcQuery] = (headers["x-amz-copy-source"] || "").replace(/^\/+/u, "").split("?");
+		const srcParts = urlDecode(rawPath).split("/");
+		if (srcParts.length < 2) return s3Error("InvalidArgument", "Copy Source must mention the source bucket and key: /sourcebucket/sourcekey", 400);
+		const srcBucketName = srcParts[0];
+		const srcKey = srcParts.slice(1).join("/");
+		const srcBucket = this.storage.buckets.get(srcBucketName);
+		if (!srcBucket) return noSuchBucket(srcBucketName);
+		const destBucket = this.storage.buckets.get(destBucketName);
+		if (!destBucket) return noSuchBucket(destBucketName);
+		let srcVersionId;
+		if (srcQuery) srcVersionId = new URLSearchParams(srcQuery).get("versionId") ?? void 0;
+		let srcObj;
+		if (srcVersionId) {
+			const ventry = (this.storage.objectVersions.get([srcBucketName, srcKey]) || []).find((v) => v.versionId === srcVersionId);
+			if (!ventry || ventry.isDeleteMarker) return s3Error("NoSuchVersion", "The specified version does not exist.", 404, `/${srcBucketName}/${srcKey}`);
+			srcObj = this.objectRecordFromVersion(ventry);
+		} else {
+			if (!(srcKey in srcBucket.objects)) return s3Error("NoSuchKey", "The specified key does not exist.", 404, `/${srcBucketName}/${srcKey}`);
+			srcObj = srcBucket.objects[srcKey];
+		}
+		const copySrcVid = srcVersionId || srcObj.versionId;
+		const srcEtag = srcObj.etag.replaceAll(/^"|"$/gu, "");
+		const srcMtime = parseHttpDate(srcObj.lastModified);
+		const ifMatch = headers["x-amz-copy-source-if-match"];
+		if (ifMatch) {
+			if (ifMatch.replaceAll(/^"|"$/gu, "") !== srcEtag) return preconditionFailed();
+		} else {
+			const unmod = parseHttpDate(headers["x-amz-copy-source-if-unmodified-since"]);
+			if (unmod && srcMtime && srcMtime.getTime() > unmod.getTime()) return preconditionFailed();
+		}
+		const ifNoneMatch = headers["x-amz-copy-source-if-none-match"];
+		if (ifNoneMatch) {
+			if (ifNoneMatch.replaceAll(/^"|"$/gu, "") === srcEtag) return preconditionFailed();
+		} else {
+			const mod = parseHttpDate(headers["x-amz-copy-source-if-modified-since"]);
+			if (mod && srcMtime && srcMtime.getTime() <= mod.getTime()) return preconditionFailed();
+		}
+		const directive = (headers["x-amz-metadata-directive"] || "COPY").toUpperCase();
+		let metadata;
+		let contentType = srcObj.contentType;
+		let contentEncoding = srcObj.contentEncoding;
+		let preserved = {};
+		if (directive === "REPLACE") {
+			metadata = this.extractUserMetadata(headers);
+			contentType = headers["content-type"] || srcObj.contentType;
+			contentEncoding = headers["content-encoding"] || srcObj.contentEncoding;
+			for (const h of PRESERVED_HEADERS) if (headers[h] !== void 0) preserved[h] = headers[h];
+		} else {
+			metadata = {};
+			Object.assign(metadata, srcObj.metadata);
+			preserved = {};
+			Object.assign(preserved, srcObj.preservedHeaders);
+		}
+		const srcBody = this.storage.readBody(srcBucketName, srcKey, srcObj);
+		const destChecksums = { ...srcObj.checksums };
+		if (headers["x-amz-sdk-checksum-algorithm"] || headers["x-amz-checksum-crc32"] || headers["x-amz-checksum-crc32c"] || headers["x-amz-checksum-crc64nvme"] || headers["x-amz-checksum-sha1"] || headers["x-amz-checksum-sha256"]) {
+			const { checksums: resolved, error: csumErr } = resolveObjectChecksums(srcBody, headers);
+			if (csumErr) return csumErr;
+			Object.assign(destChecksums, resolved);
+		}
+		const newEtag = srcObj.etag;
+		const lastModified = nowIso();
+		const destObj = {
+			body: srcBody,
+			contentType,
+			contentEncoding,
+			etag: newEtag,
+			lastModified,
+			size: srcObj.size,
+			metadata,
+			preservedHeaders: preserved,
+			checksums: destChecksums,
+			checksumType: srcObj.checksumType
+		};
+		const destPriorObj = destBucket.objects[destKey];
+		destBucket.objects[destKey] = destObj;
+		const respHeaders = {};
+		respHeaders["Content-Type"] = "application/xml";
+		if (copySrcVid) respHeaders["x-amz-copy-source-version-id"] = copySrcVid;
+		const versionId = this.recordObjectVersion(destBucketName, destKey, destPriorObj, destObj, srcBody);
+		if (versionId) respHeaders["x-amz-version-id"] = versionId;
+		const root = new XmlElement("CopyObjectResult", { xmlns: S3_NS });
+		root.subElement("LastModified", lastModified);
+		root.subElement("ETag", newEtag);
+		return [
+			200,
+			respHeaders,
+			xmlBody(root)
+		];
+	}
+	collectListEntries(bucketObjects, prefix, delimiter, maxKeys, startAfter) {
+		const rows = [];
+		const seenPrefixes = /* @__PURE__ */ new Set();
+		const sortedKeys = Object.keys(bucketObjects).filter((k) => k.startsWith(prefix)).toSorted();
+		for (const k of sortedKeys) {
+			if (delimiter) {
+				const suffix = k.slice(prefix.length);
+				const delimIdx = suffix.indexOf(delimiter);
+				if (delimIdx !== -1) {
+					const cp = prefix + suffix.slice(0, delimIdx + delimiter.length);
+					if (!seenPrefixes.has(cp)) {
+						seenPrefixes.add(cp);
+						rows.push({
+							value: cp,
+							isPrefix: true
+						});
+					}
+					continue;
+				}
+			}
+			rows.push({
+				value: k,
+				isPrefix: false
+			});
+		}
+		let filteredRows = rows;
+		if (startAfter) filteredRows = rows.filter((r) => r.value > startAfter);
+		const contents = [];
+		const commonPrefixes = [];
+		let isTruncated = false;
+		let nextMarker = "";
+		for (let i = 0; i < filteredRows.length; i += 1) {
+			if (i >= maxKeys) {
+				isTruncated = true;
+				break;
+			}
+			const r = filteredRows[i];
+			if (r.isPrefix) commonPrefixes.push(r.value);
+			else contents.push(r.value);
+			nextMarker = r.value;
+		}
+		return {
+			contents,
+			commonPrefixes,
+			isTruncated,
+			nextMarker
+		};
+	}
+	listObjectsV2(bucketName, queryParams) {
+		const bucket = this.storage.buckets.get(bucketName);
+		if (!bucket) return noSuchBucket(bucketName);
+		const prefix = qp(queryParams, "prefix");
+		const delimiter = qp(queryParams, "delimiter");
+		const maxKeys = Math.trunc(Number(qp(queryParams, "max-keys", "1000"))) || 1e3;
+		const continuation = qp(queryParams, "continuation-token");
+		const startAfter = qp(queryParams, "start-after");
+		const encodingType = qp(queryParams, "encoding-type");
+		const encode = encodingType === "url";
+		let effectiveStart = startAfter;
+		if (continuation) try {
+			effectiveStart = Buffer.from(continuation, "base64").toString("utf-8");
+		} catch {
+			effectiveStart = continuation;
+		}
+		const { contents, commonPrefixes, isTruncated, nextMarker } = this.collectListEntries(bucket.objects, prefix, delimiter, maxKeys, effectiveStart);
+		const root = new XmlElement("ListBucketResult", { xmlns: S3_NS });
+		root.subElement("Name", bucketName);
+		root.subElement("Prefix", encode && prefix ? urlEncode(prefix, true) : prefix);
+		if (delimiter) root.subElement("Delimiter", encode ? urlEncode(delimiter, true) : delimiter);
+		if (encodingType) root.subElement("EncodingType", encodingType);
+		root.subElement("MaxKeys", String(maxKeys));
+		root.subElement("KeyCount", String(contents.length + commonPrefixes.length));
+		root.subElement("IsTruncated", isTruncated ? "true" : "false");
+		if (continuation) root.subElement("ContinuationToken", continuation);
+		if (startAfter) root.subElement("StartAfter", encode ? urlEncode(startAfter, true) : startAfter);
+		if (isTruncated && nextMarker) {
+			const token = Buffer.from(nextMarker, "utf-8").toString("base64");
+			root.subElement("NextContinuationToken", token);
+		}
+		for (const k of contents) {
+			const obj = bucket.objects[k];
+			const c = root.subElement("Contents");
+			c.subElement("Key", encode ? urlEncode(k, true) : k);
+			c.subElement("LastModified", obj.lastModified);
+			c.subElement("ETag", obj.etag);
+			c.subElement("Size", String(obj.size));
+			c.subElement("StorageClass", "STANDARD");
+		}
+		for (const cp of commonPrefixes.toSorted()) root.subElement("CommonPrefixes").subElement("Prefix", encode ? urlEncode(cp, true) : cp);
+		return [
+			200,
+			{ "Content-Type": "application/xml" },
+			xmlBody(root)
+		];
+	}
+	listObjectVersions(bucketName, queryParams) {
+		const bucket = this.storage.buckets.get(bucketName);
+		if (!bucket) return noSuchBucket(bucketName);
+		const prefix = qp(queryParams, "prefix");
+		const delimiter = qp(queryParams, "delimiter");
+		const keyMarker = qp(queryParams, "key-marker");
+		const versionIdMarker = qp(queryParams, "version-id-marker");
+		const maxKeys = Math.trunc(Number(qp(queryParams, "max-keys", "1000"))) || 1e3;
+		const root = new XmlElement("ListVersionsResult", { xmlns: S3_NS });
+		root.subElement("Name", bucketName);
+		root.subElement("Prefix", prefix);
+		if (delimiter) root.subElement("Delimiter", delimiter);
+		root.subElement("KeyMarker", keyMarker);
+		root.subElement("VersionIdMarker", versionIdMarker);
+		root.subElement("MaxKeys", String(maxKeys));
+		const inPage = (k) => {
+			if (!k.startsWith(prefix)) return false;
+			if (versionIdMarker) return k >= keyMarker;
+			return k > keyMarker;
+		};
+		const allKeys = /* @__PURE__ */ new Set();
+		for (const k of Object.keys(bucket.objects)) if (inPage(k)) allKeys.add(k);
+		for (const [bn, k] of this.storage.objectVersions.keys()) if (bn === bucketName && inPage(k)) allKeys.add(k);
+		const sortedKeys = [...allKeys].toSorted();
+		const commonPrefixes = /* @__PURE__ */ new Set();
+		const remainingKeys = [];
+		if (delimiter) for (const k of sortedKeys) {
+			const suffix = k.slice(prefix.length);
+			const cut = suffix.indexOf(delimiter);
+			if (cut === -1) remainingKeys.push(k);
+			else commonPrefixes.add(prefix + suffix.slice(0, cut + delimiter.length));
+		}
+		else remainingKeys.push(...sortedKeys);
+		const stream = [];
+		for (const cp of commonPrefixes) stream.push({
+			type: "prefix",
+			value: cp
+		});
+		for (const k of remainingKeys) stream.push({
+			type: "key",
+			value: k
+		});
+		stream.sort((a, b) => a.value.localeCompare(b.value));
+		let count = 0;
+		let isTruncated = false;
+		let nextKeyMarker = null;
+		let nextVersionIdMarker = null;
+		const emitVersion = (k, v) => {
+			if (v.isDeleteMarker) {
+				const dm = root.subElement("DeleteMarker");
+				dm.subElement("Key", k);
+				dm.subElement("VersionId", v.versionId);
+				dm.subElement("IsLatest", v.isLatest ? "true" : "false");
+				dm.subElement("LastModified", v.lastModified);
+			} else {
+				const ver = root.subElement("Version");
+				ver.subElement("Key", k);
+				ver.subElement("VersionId", v.versionId);
+				ver.subElement("IsLatest", v.isLatest ? "true" : "false");
+				ver.subElement("LastModified", v.lastModified);
+				ver.subElement("ETag", v.etag);
+				ver.subElement("Size", String(v.size));
+				ver.subElement("StorageClass", "STANDARD");
+			}
+		};
+		for (const item of stream) {
+			if (count >= maxKeys) {
+				isTruncated = true;
+				break;
+			}
+			if (item.type === "prefix") {
+				root.subElement("CommonPrefixes").subElement("Prefix", item.value);
+				nextKeyMarker = item.value;
+				nextVersionIdMarker = null;
+				count += 1;
+				continue;
+			}
+			const k = item.value;
+			const versions = this.storage.objectVersions.get([bucketName, k]);
+			if (versions && versions.length > 0) {
+				let skipping = Boolean(versionIdMarker && k === keyMarker);
+				for (let i = versions.length - 1; i >= 0; i -= 1) {
+					const v = versions[i];
+					if (skipping) {
+						if (v.versionId === versionIdMarker) skipping = false;
+						continue;
+					}
+					if (count >= maxKeys) {
+						isTruncated = true;
+						break;
+					}
+					emitVersion(k, v);
+					nextKeyMarker = k;
+					nextVersionIdMarker = v.versionId;
+					count += 1;
+				}
+			} else {
+				const obj = bucket.objects[k];
+				if (!obj) continue;
+				const ver = root.subElement("Version");
+				ver.subElement("Key", k);
+				ver.subElement("VersionId", obj.versionId || "null");
+				ver.subElement("IsLatest", "true");
+				ver.subElement("LastModified", obj.lastModified);
+				ver.subElement("ETag", obj.etag);
+				ver.subElement("Size", String(obj.size));
+				ver.subElement("StorageClass", "STANDARD");
+				nextKeyMarker = k;
+				nextVersionIdMarker = obj.versionId || "null";
+				count += 1;
+			}
+		}
+		root.subElement("IsTruncated", isTruncated ? "true" : "false");
+		if (isTruncated && nextKeyMarker !== null) {
+			root.subElement("NextKeyMarker", nextKeyMarker);
+			root.subElement("NextVersionIdMarker", nextVersionIdMarker || "null");
+		}
+		return [
+			200,
+			{ "Content-Type": "application/xml" },
+			xmlBody(root)
+		];
+	}
+	expireMultipartUploads(bucketName) {
+		const rules = this.storage.bucketLifecycle.get(bucketName);
+		if (!Array.isArray(rules)) return;
+		for (const [uploadId, upload] of this.storage.multipartUploads.entries()) {
+			if (upload.bucket !== bucketName) continue;
+			for (const rule of rules) {
+				const days = rule.AbortIncompleteMultipartUpload?.DaysAfterInitiation;
+				if (rule.Status !== "Enabled" || !days) continue;
+				if (upload.key.startsWith(rule.Filter?.Prefix ?? "") && Date.now() - Date.parse(upload.created) >= days * 864e5) {
+					this.storage.multipartUploads.delete(uploadId);
+					break;
+				}
+			}
+		}
+	}
+	createMultipartUpload(bucketName, key, headers) {
+		if (!this.storage.buckets.get(bucketName)) return noSuchBucket(bucketName);
+		const { algorithm: checksumAlgorithm, error: csumErr } = resolveMultipartChecksumAlgorithm(headers);
+		if (csumErr) return csumErr;
+		const uploadId = newUuid();
+		const contentType = headers["content-type"] || "application/octet-stream";
+		const contentEncoding = headers["content-encoding"];
+		const metadata = this.extractUserMetadata(headers);
+		const preserved = {};
+		for (const h of PRESERVED_HEADERS) if (headers[h] !== void 0) preserved[h] = headers[h];
+		this.storage.multipartUploads.set(uploadId, {
+			bucket: bucketName,
+			key,
+			parts: {},
+			metadata,
+			contentType,
+			contentEncoding,
+			preservedHeaders: preserved,
+			checksumAlgorithm,
+			created: nowIso()
+		});
+		const root = new XmlElement("InitiateMultipartUploadResult", { xmlns: S3_NS });
+		root.subElement("Bucket", bucketName);
+		root.subElement("Key", key);
+		root.subElement("UploadId", uploadId);
+		const csumHeaders = {};
+		if (checksumAlgorithm) {
+			csumHeaders["x-amz-checksum-algorithm"] = checksumAlgorithm;
+			csumHeaders["x-amz-checksum-type"] = "COMPOSITE";
+		}
+		return [
+			200,
+			{
+				"Content-Type": "application/xml",
+				...csumHeaders
+			},
+			xmlBody(root)
+		];
+	}
+	uploadPart(bucketName, key, body, queryParams, headers) {
+		if (!this.storage.buckets.get(bucketName)) return noSuchBucket(bucketName);
+		const uploadId = qp(queryParams, "uploadId");
+		const partNumberStr = qp(queryParams, "partNumber");
+		const upload = this.storage.multipartUploads.get(uploadId);
+		if (!upload || upload.bucket !== bucketName || upload.key !== key) return s3Error("NoSuchUpload", "The specified multipart upload does not exist.", 404, `/${bucketName}/${key}`);
+		const pn = Number(partNumberStr);
+		if (!Number.isInteger(pn) || pn < 1 || pn > 1e4) return s3Error("InvalidArgument", "Part number must be an integer between 1 and 10000, inclusive.", 400);
+		const md5Err = validateContentMd5(headers, body);
+		if (md5Err) return md5Err;
+		const { checksums: partChecksums, error: csumErr } = resolvePartChecksums(body, headers, upload);
+		if (csumErr) return csumErr;
+		const etag = `"${md5Hex(body)}"`;
+		upload.parts[pn] = {
+			body,
+			etag,
+			size: body.length,
+			lastModified: nowIso(),
+			checksums: partChecksums
+		};
+		const csumHeaders = {};
+		for (const [alg, val] of Object.entries(partChecksums)) csumHeaders[`x-amz-checksum-${alg.toLowerCase()}`] = val;
+		return [
+			200,
+			{
+				ETag: etag,
+				...csumHeaders
+			},
+			Buffer.alloc(0)
+		];
+	}
+	completeMultipartUpload(bucketName, key, body, queryParams, headers = {}) {
+		const bucket = this.storage.buckets.get(bucketName);
+		if (!bucket) return noSuchBucket(bucketName);
+		const uploadId = qp(queryParams, "uploadId");
+		const cached = this.storage.completedMultipartUploads.get(uploadId);
+		if (cached && cached.bucket === bucketName && cached.key === key) return cached.response;
+		const upload = this.storage.multipartUploads.get(uploadId);
+		if (!upload || upload.bucket !== bucketName || upload.key !== key) return s3Error("NoSuchUpload", "The specified multipart upload does not exist.", 404, `/${bucketName}/${key}`);
+		const precondErr = this.checkPutPreconditions(headers, bucket.objects[key]);
+		if (precondErr) return precondErr;
+		let root;
+		try {
+			root = parseXml(body);
+		} catch {
+			return s3Error("MalformedXML", "The XML you provided was not well-formed or did not validate against our published schema.", 400, `/${bucketName}/${key}`);
+		}
+		const orderedParts = [];
+		for (const partEl of root.children) if (partEl.localName() === "Part") {
+			let pnText;
+			let etagText;
+			const partChecksums = {};
+			for (const child of partEl.children) {
+				const local = child.localName();
+				if (local === "PartNumber") pnText = child.text;
+				else if (local === "ETag") etagText = child.text;
+				else if (local.startsWith("Checksum")) partChecksums[local.slice(8).toUpperCase()] = child.text || "";
+			}
+			if (pnText === void 0) return s3Error("InvalidPart", "Each part requires a part number.", 400);
+			if (pnText !== void 0) orderedParts.push({
+				pn: Number(pnText),
+				reqEtag: etagText,
+				reqChecksums: partChecksums
+			});
+		}
+		if (root.localName() !== "CompleteMultipartUpload" || orderedParts.length === 0 || orderedParts.length > 1e4) return s3Error("MalformedXML", "A completion request must contain between 1 and 10000 parts.", 400);
+		let previousPartNumber = 0;
+		for (const part of orderedParts) {
+			if (!Number.isInteger(part.pn) || part.pn < 1 || part.pn > 1e4 || !part.reqEtag) return s3Error("InvalidPart", "Each part requires a valid part number and ETag.", 400);
+			if (part.pn <= previousPartNumber) return s3Error("InvalidPartOrder", "Parts must be in ascending order without duplicates.", 400);
+			previousPartNumber = part.pn;
+		}
+		const md5Digests = [];
+		const combinedParts = [];
+		const partDigests = [];
+		const checksumAlgorithm = upload.checksumAlgorithm;
+		for (const { pn, reqEtag, reqChecksums } of orderedParts) {
+			const stored = upload.parts[pn];
+			if (!stored) return s3Error("InvalidPart", "One or more of the specified parts could not be found.", 400);
+			if (reqEtag && reqEtag.replaceAll(/^"|"$/gu, "") !== stored.etag.replaceAll(/^"|"$/gu, "")) return s3Error("InvalidPart", `One or more of the specified parts could not be found. The following part numbers are invalid: ${pn}`, 400);
+			if (pn !== orderedParts.at(-1)?.pn && stored.size < 5242880) return s3Error("EntityTooSmall", "Each nonfinal part must contain at least 5 MiB.", 400);
+			const storedChecksums = stored.checksums || {};
+			for (const [alg, val] of Object.entries(reqChecksums)) if (val && storedChecksums[alg] !== val) return s3Error("InvalidPart", `One or more of the specified parts could not be found. The following part numbers are invalid: ${pn}`, 400);
+			if (checksumAlgorithm) partDigests.push(storedChecksums[checksumAlgorithm]);
+			md5Digests.push(createHash("md5").update(stored.body).digest());
+			combinedParts.push(stored.body);
+		}
+		const composite = compositeChecksum(checksumAlgorithm, partDigests);
+		if (checksumAlgorithm) {
+			const requested = headers[`x-amz-checksum-${checksumAlgorithm.toLowerCase()}`];
+			if (requested && requested !== composite) return s3Error("BadDigest", `The ${checksumAlgorithm} you specified did not match the calculated checksum.`, 400, `/${bucketName}/${key}`);
+		}
+		const finalEtag = `"${createHash("md5").update(Buffer.concat(md5Digests)).digest("hex")}-${orderedParts.length}"`;
+		const combined = Buffer.concat(combinedParts);
+		const obj = {
+			body: combined,
+			contentType: upload.contentType,
+			contentEncoding: upload.contentEncoding,
+			etag: finalEtag,
+			lastModified: nowIso(),
+			size: combined.length,
+			metadata: upload.metadata,
+			preservedHeaders: upload.preservedHeaders,
+			checksums: composite && checksumAlgorithm ? { [checksumAlgorithm]: composite } : {},
+			checksumType: composite ? "COMPOSITE" : void 0
+		};
+		const priorObj = bucket.objects[key];
+		bucket.objects[key] = obj;
+		this.storage.multipartUploads.delete(uploadId);
+		const respHeaders = {};
+		respHeaders["Content-Type"] = "application/xml";
+		const versionId = this.recordObjectVersion(bucketName, key, priorObj, obj, combined);
+		if (versionId) respHeaders["x-amz-version-id"] = versionId;
+		const rootResult = new XmlElement("CompleteMultipartUploadResult", { xmlns: S3_NS });
+		const requestHost = headers["host"];
+		let s3Host = "http://localhost:4566";
+		if (requestHost) s3Host = `${headers["x-forwarded-proto"] || "http"}://${requestHost}`;
+		rootResult.subElement("Location", `${s3Host}/${bucketName}/${key}`);
+		rootResult.subElement("Bucket", bucketName);
+		rootResult.subElement("Key", key);
+		rootResult.subElement("ETag", finalEtag);
+		if (composite && checksumAlgorithm) {
+			rootResult.subElement(`Checksum${checksumAlgorithm}`, composite);
+			rootResult.subElement("ChecksumType", "COMPOSITE");
+		}
+		const response = [
+			200,
+			respHeaders,
+			xmlBody(rootResult)
+		];
+		this.storage.completedMultipartUploads.set(uploadId, {
+			bucket: bucketName,
+			key,
+			response
+		});
+		const completed = this.storage.completedMultipartUploads._data;
+		if (completed.size > 1e3) {
+			const oldest = completed.keys().next().value;
+			if (oldest !== void 0) completed.delete(oldest);
+		}
+		return response;
+	}
+	abortMultipartUpload(bucketName, key, queryParams) {
+		if (!this.storage.buckets.get(bucketName)) return noSuchBucket(bucketName);
+		const uploadId = qp(queryParams, "uploadId");
+		const upload = this.storage.multipartUploads.get(uploadId);
+		if (!upload || upload.bucket !== bucketName || upload.key !== key) return s3Error("NoSuchUpload", "The specified multipart upload does not exist.", 404, `/${bucketName}/${key}`);
+		this.storage.multipartUploads.delete(uploadId);
+		return [
+			204,
+			{},
+			Buffer.alloc(0)
+		];
+	}
+};
+//#endregion
+//#region src/server/server.ts
+function collectRequestBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+/**
+* Creates a Node.js `http.Server` request listener that serves the local S3 emulator API.
+*
+* @param options - Server configuration options (region, persistence, data directory).
+* @returns A Node.js `RequestListener` function `(req, res) => Promise<void>`.
+*
+* @example
+* ```ts
+* import { createServer } from "node:http";
+* import { createS3NodeHandler } from "local-s3/server";
+*
+* const server = createServer(createS3NodeHandler({ persist: true }));
+* server.listen(4566, "127.0.0.1");
+* ```
+*/
+function createS3NodeHandler(options = {}) {
+	const s3 = new S3Service(options);
+	return async (req, res) => {
+		const method = (req.method || "GET").toUpperCase();
+		const [pathPart, queryPart] = (req.url || "/").split("?");
+		const queryParams = parseQueryParams(queryPart || "");
+		const headers = {};
+		for (const [k, v] of Object.entries(req.headers)) if (v !== void 0) headers[k.toLowerCase()] = Array.isArray(v) ? v.join(", ") : v;
+		const accountId = headers["x-amz-account-id"] || qp(queryParams, "accountId") || void 0;
+		const region = headers["x-amz-region"] || qp(queryParams, "region") || options.region || "us-east-1";
+		let path = pathPart;
+		const signedPath = path;
+		try {
+			path = decodeURIComponent(path);
+		} catch {
+			res.writeHead(400);
+			res.end("Invalid URI encoding");
+			return;
+		}
+		let body;
+		try {
+			body = await collectRequestBody(req);
+		} catch {
+			res.destroy();
+			return;
+		}
+		try {
+			const [status, respHeaders, respBody] = withAccountContext({
+				accountId,
+				region
+			}, () => s3.handleRequest(method, path, headers, body, queryParams, signedPath));
+			res.writeHead(status, respHeaders);
+			res.end(respBody);
+		} catch {
+			if (!res.headersSent) {
+				res.writeHead(500, { "Content-Type": "application/xml" });
+				res.end("<Error><Code>InternalError</Code><Message>We encountered an internal error. Please try again.</Message></Error>");
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite.ts
+const isColorSupported = !("NO_COLOR" in process.env) && (Boolean(process.env.FORCE_COLOR) || process.stdout.isTTY && process.env.TERM !== "dumb");
+function dim(text) {
+	return isColorSupported ? `\u001B[2m${text}\u001B[22m` : text;
+}
+function boldGreen(text) {
+	return isColorSupported ? `\u001B[1m\u001B[32m${text}\u001B[39m\u001B[22m` : text;
+}
+function boldRed(text) {
+	return isColorSupported ? `\u001B[1m\u001B[31m${text}\u001B[39m\u001B[22m` : text;
+}
+function formatTime() {
+	return new Intl.DateTimeFormat(void 0, {
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	}).format(/* @__PURE__ */ new Date());
+}
+const runningServersKey = Symbol.for("local-s3.vite.runningServers");
+const runtime = globalThis;
+runtime[runningServersKey] ??= /* @__PURE__ */ new Map();
+const runningServers = runtime[runningServersKey];
+/** Start the embedded S3 emulator for Vite development. */
+function s3Emulator(options = {}) {
+	const cleanups = /* @__PURE__ */ new WeakMap();
+	return {
+		name: "vite-plugin-local-s3",
+		apply: "serve",
+		async configureServer(vite) {
+			const host = "127.0.0.1";
+			const port = options.port ?? 4566;
+			const targetKey = `${host}:${port}`;
+			const rootKey = `root:${vite.config.root}`;
+			await Promise.all([
+				runningServers.get(targetKey)?.(),
+				runningServers.get(rootKey)?.(),
+				vite.config.inlineConfig ? runningServers.get(vite.config.inlineConfig)?.() : void 0
+			]);
+			const handler = createS3NodeHandler({
+				region: "us-east-1",
+				persist: true,
+				dataDir: path.resolve(vite.config.root, ".emulator/s3")
+			});
+			const server = createServer(async (request, response) => {
+				try {
+					await handler(request, response);
+				} catch (error) {
+					vite.config.logger.error(`${dim(formatTime())} ${boldRed("[s3-emulator]")} Request failed: ${String(error)}`);
+					if (response.headersSent) response.destroy();
+					else {
+						response.writeHead(500);
+						response.end("Internal Server Error");
+					}
+				}
+			});
+			let closing;
+			let boundKey;
+			function stop() {
+				closing ??= (async () => {
+					try {
+						await new Promise((resolve, reject) => {
+							server.close((error) => {
+								if (error && !("code" in error && error.code === "ERR_SERVER_NOT_RUNNING")) reject(error);
+								else resolve();
+							});
+							server.closeAllConnections();
+						});
+					} finally {
+						if (boundKey && runningServers.get(boundKey) === stop) runningServers.delete(boundKey);
+						if (runningServers.get(targetKey) === stop) runningServers.delete(targetKey);
+						if (runningServers.get(rootKey) === stop) runningServers.delete(rootKey);
+						if (vite.config.inlineConfig && runningServers.get(vite.config.inlineConfig) === stop) runningServers.delete(vite.config.inlineConfig);
+					}
+				})();
+				return closing;
+			}
+			runningServers.set(targetKey, stop);
+			runningServers.set(rootKey, stop);
+			if (vite.config.inlineConfig) runningServers.set(vite.config.inlineConfig, stop);
+			for (const environment of Object.values(vite.environments)) cleanups.set(environment, stop);
+			vite.httpServer?.on("close", () => {
+				stop();
+			});
+			const originalClose = vite.close.bind(vite);
+			vite.close = async () => {
+				await stop();
+				return originalClose();
+			};
+			try {
+				await new Promise((resolve, reject) => {
+					server.once("error", reject);
+					server.listen(port, host, () => {
+						server.off("error", reject);
+						resolve();
+					});
+				});
+			} catch (error) {
+				await stop();
+				await vite.close();
+				throw new Error(`[s3-emulator] Cannot listen on ${host}:${port}. Check that the address is available and no other server is using the port.`, { cause: error });
+			}
+			server.on("error", (error) => {
+				vite.config.logger.error(`${dim(formatTime())} ${boldRed("[s3-emulator]")} Server error: ${error.message}`);
+			});
+			const address = server.address();
+			if (address && typeof address !== "string") {
+				boundKey = `${host}:${address.port}`;
+				runningServers.set(boundKey, stop);
+				const endpoint = `http://${host}:${address.port}`;
+				vite.config.logger.info(`${dim(formatTime())} ${boldGreen("[s3-emulator]")} Listening at ${endpoint}`);
+			}
+		},
+		async closeBundle() {
+			await cleanups.get(this.environment)?.();
+		}
+	};
+}
+//#endregion
+export { s3Emulator };