create-monolayer-app 0.5.1 → 0.6.3

package/template/build/server/index.js

@@ -0,0 +1,1096 @@
+import { PassThrough } from "node:stream";
+import { createReadableStreamFromReadable } from "@react-router/node";
+import { Links, Meta, Outlet, Scripts, ScrollRestoration, ServerRouter, UNSAFE_withComponentProps, UNSAFE_withErrorBoundaryProps, createContext, isRouteErrorResponse } from "react-router";
+import { isbot } from "isbot";
+import { renderToPipeableStream } from "react-dom/server";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, PutObjectCommand, S3Client, UploadPartCommand } from "@aws-sdk/client-s3";
+import "@aws-sdk/lib-storage";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region node_modules/@react-router/dev/dist/config/defaults/entry.server.node.tsx
+var entry_server_node_exports = /* @__PURE__ */ __exportAll({
+	default: () => handleRequest,
+	streamTimeout: () => streamTimeout
+});
+var streamTimeout = 5e3;
+function handleRequest(request, responseStatusCode, responseHeaders, routerContext, loadContext) {
+	if (request.method.toUpperCase() === "HEAD") return new Response(null, {
+		status: responseStatusCode,
+		headers: responseHeaders
+	});
+	return new Promise((resolve, reject) => {
+		let shellRendered = false;
+		let userAgent = request.headers.get("user-agent");
+		let readyOption = userAgent && isbot(userAgent) || routerContext.isSpaMode ? "onAllReady" : "onShellReady";
+		let timeoutId = setTimeout(() => abort(), 6e3);
+		const { pipe, abort } = renderToPipeableStream(/* @__PURE__ */ jsx(ServerRouter, {
+			context: routerContext,
+			url: request.url
+		}), {
+			[readyOption]() {
+				shellRendered = true;
+				const body = new PassThrough({ final(callback) {
+					clearTimeout(timeoutId);
+					timeoutId = void 0;
+					callback();
+				} });
+				const stream = createReadableStreamFromReadable(body);
+				responseHeaders.set("Content-Type", "text/html");
+				pipe(body);
+				resolve(new Response(stream, {
+					headers: responseHeaders,
+					status: responseStatusCode
+				}));
+			},
+			onShellError(error) {
+				reject(error);
+			},
+			onError(error) {
+				responseStatusCode = 500;
+				if (shellRendered) console.error(error);
+			}
+		});
+	});
+}
+//#endregion
+//#region lib/user-context.server.ts
+var userContextMiddleware = async ({ request, context }, next) => {
+	const result = userSchema.safeParse({
+		email: request.headers.get("x-user-email"),
+		role: request.headers.get("x-user-authorization")
+	});
+	if (!result.success) throw new Response("Unauthorized", { status: 401 });
+	context.set(userContext, result.data);
+	return next();
+};
+var userSchema = z.object({
+	email: z.email(),
+	role: z.enum([
+		"owner",
+		"editor",
+		"viewer"
+	])
+});
+var userContext = createContext();
+//#endregion
+//#region app/root.tsx
+var root_exports = /* @__PURE__ */ __exportAll({
+	ErrorBoundary: () => ErrorBoundary,
+	Layout: () => Layout,
+	default: () => root_default,
+	links: () => links,
+	middleware: () => middleware
+});
+var links = () => [
+	{
+		rel: "preconnect",
+		href: "https://fonts.googleapis.com"
+	},
+	{
+		rel: "preconnect",
+		href: "https://fonts.gstatic.com",
+		crossOrigin: "anonymous"
+	},
+	{
+		rel: "stylesheet",
+		href: "https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap"
+	}
+];
+function Layout({ children }) {
+	return /* @__PURE__ */ jsxs("html", {
+		lang: "en",
+		children: [/* @__PURE__ */ jsxs("head", { children: [
+			/* @__PURE__ */ jsx("meta", { charSet: "utf-8" }),
+			/* @__PURE__ */ jsx("meta", {
+				name: "viewport",
+				content: "width=device-width, initial-scale=1"
+			}),
+			/* @__PURE__ */ jsx(Meta, {}),
+			/* @__PURE__ */ jsx(Links, {})
+		] }), /* @__PURE__ */ jsxs("body", { children: [
+			children,
+			/* @__PURE__ */ jsx(ScrollRestoration, {}),
+			/* @__PURE__ */ jsx(Scripts, {})
+		] })]
+	});
+}
+var root_default = UNSAFE_withComponentProps(function App() {
+	return /* @__PURE__ */ jsx(Outlet, {});
+});
+var ErrorBoundary = UNSAFE_withErrorBoundaryProps(function ErrorBoundary({ error }) {
+	let message = "Oops!";
+	let details = "An unexpected error occurred.";
+	let stack;
+	if (isRouteErrorResponse(error)) {
+		message = error.status === 404 ? "404" : "Error";
+		details = error.status === 404 ? "The requested page could not be found." : error.statusText || details;
+	}
+	return /* @__PURE__ */ jsxs("main", {
+		className: "container mx-auto p-4 pt-16",
+		children: [
+			/* @__PURE__ */ jsx("h1", { children: message }),
+			/* @__PURE__ */ jsx("p", { children: details }),
+			stack
+		]
+	});
+});
+var middleware = [userContextMiddleware];
+//#endregion
+//#region app/welcome/logo-dark.svg
+var logo_dark_default = "/assets/logo-dark-pX2395Y0.svg";
+//#endregion
+//#region app/welcome/logo-light.svg
+var logo_light_default = "/assets/logo-light-CVbx2LBR.svg";
+//#endregion
+//#region app/welcome/welcome.tsx
+function Welcome() {
+	return /* @__PURE__ */ jsx("main", {
+		className: "flex items-center justify-center pt-16 pb-4",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "flex min-h-0 flex-1 flex-col items-center gap-16",
+			children: [/* @__PURE__ */ jsx("header", {
+				className: "flex flex-col items-center gap-9",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "w-[500px] max-w-[100vw] p-4",
+					children: [/* @__PURE__ */ jsx("img", {
+						src: logo_light_default,
+						alt: "React Router",
+						className: "block w-full dark:hidden"
+					}), /* @__PURE__ */ jsx("img", {
+						src: logo_dark_default,
+						alt: "React Router",
+						className: "hidden w-full dark:block"
+					})]
+				})
+			}), /* @__PURE__ */ jsx("div", {
+				className: "w-full max-w-[300px] space-y-6 px-4",
+				children: /* @__PURE__ */ jsxs("nav", {
+					className: "space-y-4 rounded-3xl border border-gray-200 p-6 dark:border-gray-700",
+					children: [/* @__PURE__ */ jsx("p", {
+						className: "text-center leading-6 text-gray-700 dark:text-gray-200",
+						children: "What's next?"
+					}), /* @__PURE__ */ jsx("ul", { children: resources.map(({ href, text, icon }) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs("a", {
+						className: "group flex items-center gap-3 self-stretch p-3 leading-normal text-blue-700 hover:underline dark:text-blue-500",
+						href,
+						target: "_blank",
+						rel: "noreferrer",
+						children: [icon, text]
+					}) }, href)) })]
+				})
+			})]
+		})
+	});
+}
+var resources = [{
+	href: "https://reactrouter.com/docs",
+	text: "React Router Docs",
+	icon: /* @__PURE__ */ jsx("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		width: "24",
+		height: "20",
+		viewBox: "0 0 20 20",
+		fill: "none",
+		className: "stroke-gray-600 group-hover:stroke-current dark:stroke-gray-300",
+		children: /* @__PURE__ */ jsx("path", {
+			d: "M9.99981 10.0751V9.99992M17.4688 17.4688C15.889 19.0485 11.2645 16.9853 7.13958 12.8604C3.01467 8.73546 0.951405 4.11091 2.53116 2.53116C4.11091 0.951405 8.73546 3.01467 12.8604 7.13958C16.9853 11.2645 19.0485 15.889 17.4688 17.4688ZM2.53132 17.4688C0.951566 15.8891 3.01483 11.2645 7.13974 7.13963C11.2647 3.01471 15.8892 0.951453 17.469 2.53121C19.0487 4.11096 16.9854 8.73551 12.8605 12.8604C8.73562 16.9853 4.11107 19.0486 2.53132 17.4688Z",
+			strokeWidth: "1.5",
+			strokeLinecap: "round"
+		})
+	})
+}, {
+	href: "https://rmx.as/discord",
+	text: "Join Discord",
+	icon: /* @__PURE__ */ jsx("svg", {
+		xmlns: "http://www.w3.org/2000/svg",
+		width: "24",
+		height: "20",
+		viewBox: "0 0 24 20",
+		fill: "none",
+		className: "stroke-gray-600 group-hover:stroke-current dark:stroke-gray-300",
+		children: /* @__PURE__ */ jsx("path", {
+			d: "M15.0686 1.25995L14.5477 1.17423L14.2913 1.63578C14.1754 1.84439 14.0545 2.08275 13.9422 2.31963C12.6461 2.16488 11.3406 2.16505 10.0445 2.32014C9.92822 2.08178 9.80478 1.84975 9.67412 1.62413L9.41449 1.17584L8.90333 1.25995C7.33547 1.51794 5.80717 1.99419 4.37748 2.66939L4.19 2.75793L4.07461 2.93019C1.23864 7.16437 0.46302 11.3053 0.838165 15.3924L0.868838 15.7266L1.13844 15.9264C2.81818 17.1714 4.68053 18.1233 6.68582 18.719L7.18892 18.8684L7.50166 18.4469C7.96179 17.8268 8.36504 17.1824 8.709 16.4944L8.71099 16.4904C10.8645 17.0471 13.128 17.0485 15.2821 16.4947C15.6261 17.1826 16.0293 17.8269 16.4892 18.4469L16.805 18.8725L17.3116 18.717C19.3056 18.105 21.1876 17.1751 22.8559 15.9238L23.1224 15.724L23.1528 15.3923C23.5873 10.6524 22.3579 6.53306 19.8947 2.90714L19.7759 2.73227L19.5833 2.64518C18.1437 1.99439 16.6386 1.51826 15.0686 1.25995ZM16.6074 10.7755L16.6074 10.7756C16.5934 11.6409 16.0212 12.1444 15.4783 12.1444C14.9297 12.1444 14.3493 11.6173 14.3493 10.7877C14.3493 9.94885 14.9378 9.41192 15.4783 9.41192C16.0471 9.41192 16.6209 9.93851 16.6074 10.7755ZM8.49373 12.1444C7.94513 12.1444 7.36471 11.6173 7.36471 10.7877C7.36471 9.94885 7.95323 9.41192 8.49373 9.41192C9.06038 9.41192 9.63892 9.93712 9.6417 10.7815C9.62517 11.6239 9.05462 12.1444 8.49373 12.1444Z",
+			strokeWidth: "1.5"
+		})
+	})
+}];
+//#endregion
+//#region app/routes/home.tsx
+var home_exports = /* @__PURE__ */ __exportAll({
+	default: () => home_default,
+	meta: () => meta
+});
+function meta({}) {
+	return [{ title: "New React Router App" }, {
+		name: "description",
+		content: "Welcome to React Router!"
+	}];
+}
+var home_default = UNSAFE_withComponentProps(function Home() {
+	return /* @__PURE__ */ jsx(Welcome, {});
+});
+//#endregion
+//#region vendor/file-bucket/lib/xml.ts
+var 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;
+}
+//#endregion
+//#region vendor/file-bucket/lib/multipart.ts
+function uploadError(name, message, cause) {
+	return Object.assign(new Error(message, { cause }), { name });
+}
+function delay(ms, signal) {
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", abort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", abort, { once: true });
+	});
+}
+async function responseError(response) {
+	let code = "UploadFailed";
+	try {
+		const error = parseXml(await response.text());
+		code = error.findText("Code") || code;
+		if (code === "AccessDenied" && /expired/iu.test(error.findText("Message") || "")) code = "UploadExpired";
+	} catch {}
+	if (code === "RequestExpired" || code === "ExpiredToken") code = "UploadExpired";
+	return uploadError(code, `S3 upload request failed (${response.status}, ${code}).`);
+}
+/** Hydrate the wire descriptor without Node.js or AWS SDK runtime dependencies. */
+function createMultipartUploadClient(descriptor) {
+	const controller = new AbortController();
+	let state = "ready";
+	let active;
+	let cleaned = false;
+	let cleaning;
+	function checkExpiry() {
+		if (Date.now() >= descriptor.expiresAt) throw uploadError("UploadExpired", "The multipart upload URLs have expired. Create a new handle.");
+	}
+	async function sendPart(url, body, signal) {
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			signal.throwIfAborted();
+			checkExpiry();
+			let response;
+			try {
+				response = await fetch(url, {
+					method: "PUT",
+					body,
+					signal: AbortSignal.any([signal, AbortSignal.timeout(12e4)])
+				});
+			} catch (error) {
+				signal.throwIfAborted();
+				if (attempt === 2) throw error;
+				await delay(200 * 2 ** attempt, signal);
+				continue;
+			}
+			if (response.ok) {
+				const etag = response.headers.get("etag");
+				await response.arrayBuffer();
+				if (!etag) throw uploadError("MissingETag", "S3 did not expose the part ETag. Check the bucket CORS configuration.");
+				return etag;
+			}
+			const error = await responseError(response);
+			if (attempt === 2 || response.status !== 429 && response.status < 500) throw error;
+			await delay(200 * 2 ** attempt, signal);
+		}
+		throw new Error("Part upload retry limit reached.");
+	}
+	async function cleanUp() {
+		if (cleaned) return;
+		if (cleaning) return cleaning;
+		cleaning = (async () => {
+			const response = await fetch(descriptor.abortUrl, {
+				method: "DELETE",
+				signal: AbortSignal.timeout(15e3)
+			});
+			if (!response.ok && response.status !== 404) throw await responseError(response);
+			await response.arrayBuffer();
+			cleaned = true;
+		})();
+		try {
+			await cleaning;
+		} finally {
+			cleaning = void 0;
+		}
+	}
+	async function execute(body, options) {
+		const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+		try {
+			signal.throwIfAborted();
+			checkExpiry();
+			const file = body instanceof Blob ? body : new Blob([body instanceof Uint8Array ? new Uint8Array(body).buffer : body]);
+			if (file.size !== descriptor.size) throw new RangeError("File size does not match the multipart upload handle.");
+			let nextPart = 0;
+			let uploadedBytes = 0;
+			const etags = Array.from({ length: descriptor.partUrls.length }, () => "");
+			const worker = async () => {
+				try {
+					while (nextPart < descriptor.partUrls.length) {
+						signal.throwIfAborted();
+						const index = nextPart;
+						nextPart += 1;
+						const start = index * descriptor.partSize;
+						const part = file.slice(start, Math.min(file.size, start + descriptor.partSize));
+						etags[index] = await sendPart(descriptor.partUrls[index], part, signal);
+						uploadedBytes += part.size;
+						options.onProgress?.({
+							uploadedBytes,
+							totalBytes: descriptor.size
+						});
+					}
+				} catch (error) {
+					controller.abort(error);
+					throw error;
+				}
+			};
+			const failure = (await Promise.allSettled(Array.from({ length: Math.min(4, etags.length) }, worker))).find((result) => result.status === "rejected");
+			if (failure?.status === "rejected") throw failure.reason;
+			signal.throwIfAborted();
+			checkExpiry();
+			const xml = `<CompleteMultipartUpload>${etags.map((etag, index) => `<Part><PartNumber>${index + 1}</PartNumber><ETag>${escapeXml(etag)}</ETag></Part>`).join("")}</CompleteMultipartUpload>`;
+			let response;
+			let result;
+			try {
+				response = await fetch(descriptor.completeUrl, {
+					method: "POST",
+					body: xml,
+					headers: { "Content-Type": "application/xml" },
+					signal: AbortSignal.any([signal, AbortSignal.timeout(3e5)])
+				});
+				result = parseXml(await response.text());
+			} catch (error) {
+				state = "unknown";
+				throw uploadError("UploadCompletionUnknown", "The completion result is unknown. Check the object before retrying.", error);
+			}
+			if (result.localName() === "Error") throw uploadError(result.findText("Code") || "UploadFailed", result.findText("Message") || "S3 rejected multipart completion.");
+			if (!response.ok || result.localName() !== "CompleteMultipartUploadResult" || !result.findText("ETag")) {
+				state = "unknown";
+				throw uploadError("UploadCompletionUnknown", "S3 did not return a valid completion result. Check the object before retrying.");
+			}
+			state = "completed";
+		} catch (error) {
+			controller.abort(error);
+			if (state !== "unknown") {
+				state = signal.aborted ? "aborted" : "failed";
+				try {
+					await cleanUp();
+				} catch (cleanupError) {
+					throw uploadError(error instanceof Error ? error.name : "UploadFailed", "Upload failed and its session could not be cleaned up.", new AggregateError([error, cleanupError], "Upload and cleanup failed."));
+				}
+			}
+			throw error;
+		}
+	}
+	const isCompleted = () => state === "completed";
+	return {
+		async upload(body, options = {}) {
+			if (state !== "ready") throw uploadError("InvalidUploadState", "This multipart upload handle has already been used.");
+			state = "uploading";
+			active = execute(body, options);
+			await active;
+		},
+		async abort() {
+			if (isCompleted()) return;
+			controller.abort(new DOMException("Upload aborted.", "AbortError"));
+			if (active) try {
+				await active;
+			} catch {}
+			if (isCompleted()) return;
+			await cleanUp();
+			state = "aborted";
+		},
+		toJSON: () => descriptor
+	};
+}
+var DEFAULT_PART_SIZE = 8388608;
+var MAX_PARTS = 1e4;
+var MAX_PART_SIZE = 5368709120;
+function multipartPartSize(size) {
+	if (size === void 0) return DEFAULT_PART_SIZE;
+	if (!Number.isSafeInteger(size) || size < 0) throw new RangeError("Upload size must be a nonnegative safe integer.");
+	const partSize = Math.max(DEFAULT_PART_SIZE, Math.ceil(size / MAX_PARTS));
+	if (partSize > MAX_PART_SIZE) throw new RangeError("Upload exceeds the multipart size limit.");
+	return partSize;
+}
+//#endregion
+//#region vendor/file-bucket/lib/file-bucket.ts
+/** Shared file bucket definition for server and browser code. */
+var FileBucket = class {
+	name;
+	constructor(name) {
+		this.name = name;
+	}
+};
+//#endregion
+//#region vendor/file-bucket/index.server.ts
+var clients = /* @__PURE__ */ new WeakMap();
+function getClient(bucket) {
+	const client = clients.get(bucket) ?? new S3Client(process.env.NODE_ENV === "production" ? { requestChecksumCalculation: "WHEN_REQUIRED" } : {
+		requestChecksumCalculation: "WHEN_REQUIRED",
+		endpoint: process.env.S3_EMULATOR_ENDPOINT || "http://127.0.0.1:4566",
+		region: "us-east-1",
+		forcePathStyle: true,
+		credentials: {
+			accessKeyId: "test",
+			secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || "test"
+		}
+	});
+	clients.set(bucket, client);
+	return client;
+}
+/**
+* Delete an object through S3. Deleting a missing key succeeds.
+*
+* @param bucket - Shared definition whose ID is resolved to the configured physical bucket.
+* @param path - Object key to delete.
+* @returns A promise that resolves after S3 confirms deletion.
+*/
+async function deleteFile(bucket, path) {
+	const bucketName = resolveBucketName(bucket);
+	await getClient(bucket).send(new DeleteObjectCommand({
+		Bucket: bucketName,
+		Key: path
+	}));
+}
+/**
+* Delete objects in sequential batches of up to 1,000 keys.
+*
+* An empty list sends no S3 request. Deletion is not atomic: a rejected batch may
+* already have deleted some objects, and later batches are not attempted.
+*
+* @param bucket - Shared definition whose ID is resolved to the configured physical bucket.
+* @param paths - Object keys to delete.
+* @returns A promise that resolves after all batches complete.
+* @throws {AggregateError} If S3 reports per-object deletion errors.
+*/
+async function deleteBatch(bucket, paths) {
+	if (paths.length === 0) return;
+	const bucketName = resolveBucketName(bucket);
+	const client = getClient(bucket);
+	const CHUNK_SIZE = 1e3;
+	for (let i = 0; i < paths.length; i += CHUNK_SIZE) {
+		const chunk = paths.slice(i, i + CHUNK_SIZE);
+		const result = await client.send(new DeleteObjectsCommand({
+			Bucket: bucketName,
+			Delete: {
+				Objects: chunk.map((Key) => ({ Key })),
+				Quiet: true
+			}
+		}));
+		if (result.Errors?.length) throw new AggregateError(result.Errors.map((error) => /* @__PURE__ */ new Error(`Failed to delete ${error.Key}: ${error.Code} ${error.Message ?? ""}`)), "Some files could not be deleted.");
+	}
+}
+/**
+* Sign a GET URL on the server without reading the object or checking that it exists.
+*
+* @param bucket - Shared definition whose ID is resolved to the configured physical bucket.
+* @param path - Object key to access.
+* @param options - URL lifetime in seconds (default 3600) and optional response content disposition.
+* @returns A signed URL; requesting it performs the download.
+*/
+function getUrl(bucket, path, options) {
+	const bucketName = resolveBucketName(bucket);
+	return getSignedUrl(getClient(bucket), new GetObjectCommand({
+		Bucket: bucketName,
+		Key: path,
+		ResponseContentDisposition: options?.contentDisposition
+	}), { expiresIn: options?.expiresIn ?? 3600 });
+}
+/**
+* Sign a URL for one PUT without uploading bytes or creating a multipart session.
+*
+* Send the raw body with the content-type and cache-control headers used when
+* signing. Metadata is carried in the signed query. Uploading replaces an existing key.
+*
+* @param bucket - Shared definition whose ID is resolved to the configured physical bucket.
+* @param path - Destination object key.
+* @param options - Object metadata, content headers, and URL lifetime in seconds (default 3600).
+* @returns A signed URL for a single PUT.
+*/
+function putUrl(bucket, path, options) {
+	const bucketName = resolveBucketName(bucket);
+	return getSignedUrl(getClient(bucket), new PutObjectCommand({
+		Bucket: bucketName,
+		Key: path,
+		ContentType: options?.contentType,
+		Metadata: options?.metadata,
+		CacheControl: options?.cacheControl
+	}), { expiresIn: options?.expiresIn ?? 3600 });
+}
+/**
+* Create an S3 multipart session and sign its part, completion, and abort URLs.
+*
+* The returned handle uploads once, supports cancellation and progress, and can
+* abort an unused session. Serialize with `toJSON()` and hydrate in the browser
+* with `createMultipartUploadClient`. Creation sends no file bytes.
+*
+* @param bucket - Shared definition whose ID is resolved to the configured physical bucket.
+* @param path - Destination object key.
+* @param options - Expected byte size, object metadata, content headers, and URL lifetime (default 3600 seconds).
+* @returns A multipart handle tied to the newly created session.
+* @throws {RangeError} For an unsupported size or URL lifetime.
+*/
+async function createMultipartUploadHandle(bucket, path, options) {
+	const bucketName = resolveBucketName(bucket);
+	const partSize = multipartPartSize(options.size);
+	const expiresIn = options.expiresIn ?? 3600;
+	if (!Number.isInteger(expiresIn) || expiresIn < 1 || expiresIn > 604800) throw new RangeError("URL lifetime must be between 1 and 604800 seconds.");
+	const client = getClient(bucket);
+	const target = {
+		Bucket: bucketName,
+		Key: path
+	};
+	const { UploadId } = await client.send(new CreateMultipartUploadCommand({
+		...target,
+		ContentType: options.contentType,
+		Metadata: options.metadata,
+		CacheControl: options.cacheControl
+	}));
+	if (!UploadId) throw new Error("S3 did not return an upload ID.");
+	const session = {
+		...target,
+		UploadId
+	};
+	const expiresAt = Math.floor(Date.now() / 1e3) * 1e3 + expiresIn * 1e3;
+	try {
+		const partUrls = [];
+		const count = Math.max(1, Math.ceil(options.size / partSize));
+		for (let partNumber = 1; partNumber <= count; partNumber += 1) partUrls.push(await getSignedUrl(client, new UploadPartCommand({
+			...session,
+			PartNumber: partNumber
+		}), { expiresIn }));
+		const completeUrl = await getSignedUrl(client, new CompleteMultipartUploadCommand({
+			...session,
+			MultipartUpload: { Parts: [] }
+		}), {
+			expiresIn,
+			unsignableHeaders: /* @__PURE__ */ new Set(["content-length"])
+		});
+		const abortUrl = await getSignedUrl(client, new AbortMultipartUploadCommand(session), { expiresIn });
+		return createMultipartUploadClient({
+			__blocks: "file-bucket/multipart-upload",
+			uploadId: UploadId,
+			size: options.size,
+			partSize,
+			expiresAt,
+			partUrls,
+			completeUrl,
+			abortUrl
+		});
+	} catch (error) {
+		try {
+			await client.send(new AbortMultipartUploadCommand(session));
+		} catch (cleanupError) {
+			throw new AggregateError([error, cleanupError], "Failed to create and clean up multipart upload.", { cause: cleanupError });
+		}
+		throw error;
+	}
+}
+function resolveBucketName(bucket) {
+	const hash = createHash("sha256").update(bucket.name).digest("hex").slice(0, 8);
+	return process.env[`FILE_BUCKET_${hash}`] || bucket.name;
+}
+//#endregion
+//#region vendor/file-bucket/lib/protocol.ts
+var MAX_KEY_BYTES = 1024;
+var MAX_METADATA_ENTRIES = 50;
+var MAX_METADATA_KEY_LENGTH = 128;
+var MAX_METADATA_VALUE_LENGTH = 2048;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textByteLength(value) {
+	return new TextEncoder().encode(value).length;
+}
+function isKey(value) {
+	return typeof value === "string" && value.length > 0 && textByteLength(value) <= MAX_KEY_BYTES;
+}
+function isOptionalText(value, maxLen = 1024) {
+	return value === void 0 || typeof value === "string" && textByteLength(value) <= maxLen;
+}
+function isStringRecord(value) {
+	if (!isRecord(value)) return false;
+	const entries = Object.entries(value);
+	if (entries.length > MAX_METADATA_ENTRIES) return false;
+	return entries.every(([k, v]) => typeof v === "string" && k.length <= MAX_METADATA_KEY_LENGTH && v.length <= MAX_METADATA_VALUE_LENGTH);
+}
+function isSize(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isMetadata(input) {
+	return isOptionalText(input.contentType, 512) && isOptionalText(input.cacheControl, 512) && (input.metadata === void 0 || isStringRecord(input.metadata));
+}
+function isSigningOptions(input) {
+	return isMetadata(input) && isOptionalText(input.contentDisposition, 512) && (input.expiresIn === void 0 || isSize(input.expiresIn) && input.expiresIn >= 1 && input.expiresIn <= 604800);
+}
+function deepFreeze(object) {
+	if (object === null || typeof object !== "object") return object;
+	Object.freeze(object);
+	for (const key of Object.keys(object)) {
+		const val = object[key];
+		if (val !== null && typeof val === "object" && !Object.isFrozen(val)) deepFreeze(val);
+	}
+	return object;
+}
+function isRequest(input, maxBatchKeys = 1e3) {
+	if (!isKey(input.bucketId)) return false;
+	if (input.operation === "deleteBatch") return Array.isArray(input.paths) && input.paths.length > 0 && input.paths.length <= maxBatchKeys && input.paths.every(isKey);
+	if (!isKey(input.path)) return false;
+	switch (input.operation) {
+		case "get":
+		case "delete": return true;
+		case "getUrl":
+		case "putUrl": return isSigningOptions(input);
+		case "put": return isSize(input.size) && isMetadata(input);
+		default: return false;
+	}
+}
+function parseFileBucketRequest(value, options) {
+	if (!isRecord(value)) throw new Error("Invalid file request");
+	const input = {
+		...value,
+		operation: value.operation === void 0 ? "put" : value.operation
+	};
+	if (!isRequest(input, options?.maxBatchKeys)) throw new Error("Invalid file request");
+	return deepFreeze(input);
+}
+//#endregion
+//#region vendor/file-bucket/react-router.server.ts
+var MULTIPART_THRESHOLD = 8388608;
+var MAX_REQUEST_BYTES = 65536;
+var MAX_BATCH_KEYS = 1e3;
+async function readLimitedJson(request, maxBytes) {
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new RangeError("maxBytes must be a positive safe integer.");
+	const reader = request.body?.getReader();
+	if (!reader) throw new Response("Invalid JSON", { status: 400 });
+	const chunks = [];
+	let length = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			length += value.byteLength;
+			if (length > maxBytes) {
+				try {
+					await reader.cancel();
+				} catch {}
+				throw new Response("Request too large", { status: 413 });
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	try {
+		return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch {
+		throw new Response("Invalid JSON", { status: 400 });
+	}
+}
+async function uploadGrant(bucket, input) {
+	const options = {
+		contentType: input.contentType,
+		cacheControl: input.cacheControl,
+		metadata: input.metadata
+	};
+	if (input.size >= MULTIPART_THRESHOLD) return {
+		type: "multipart",
+		descriptor: (await createMultipartUploadHandle(bucket, input.path, {
+			...options,
+			size: input.size
+		})).toJSON()
+	};
+	const url = await putUrl(bucket, input.path, options);
+	const headers = {};
+	if (options.contentType) headers["Content-Type"] = options.contentType;
+	if (options.cacheControl) headers["Cache-Control"] = options.cacheControl;
+	return {
+		type: "single",
+		url,
+		headers
+	};
+}
+async function dispatch(bucket, input) {
+	switch (input.operation) {
+		case "delete":
+			await deleteFile(bucket, input.path);
+			return;
+		case "deleteBatch":
+			await deleteBatch(bucket, input.paths);
+			return;
+		case "get": return { url: await getUrl(bucket, input.path, { contentDisposition: "attachment" }) };
+		case "getUrl": return { url: await getUrl(bucket, input.path, {
+			expiresIn: input.expiresIn,
+			contentDisposition: input.contentDisposition
+		}) };
+		case "putUrl": return { url: await putUrl(bucket, input.path, {
+			expiresIn: input.expiresIn,
+			contentType: input.contentType,
+			metadata: input.metadata,
+			cacheControl: input.cacheControl
+		}) };
+		case "put": return uploadGrant(bucket, input);
+		default: throw new Error("Unsupported file operation");
+	}
+}
+//#endregion
+//#region app/routes/files.ts
+var files_exports = /* @__PURE__ */ __exportAll({ action: () => action });
+var action = async ({ request }) => {
+	if (request.method !== "POST") return new Response("Method not allowed", {
+		status: 405,
+		headers: { Allow: "POST" }
+	});
+	if (request.headers.get("content-type")?.toLowerCase().split(";")[0]?.trim() !== "application/json") return new Response("Unsupported Media Type", { status: 415 });
+	const contentLengthHeader = request.headers.get("content-length");
+	if (contentLengthHeader !== null) {
+		const declaredLength = Number(contentLengthHeader);
+		if (!Number.isNaN(declaredLength) && declaredLength > 65536) return new Response("Request too large", { status: 413 });
+	}
+	let value;
+	try {
+		value = await readLimitedJson(request, MAX_REQUEST_BYTES);
+	} catch (error) {
+		if (error instanceof Response) return error;
+		return new Response("Invalid JSON", { status: 400 });
+	}
+	let input;
+	try {
+		input = parseFileBucketRequest(value, { maxBatchKeys: MAX_BATCH_KEYS });
+	} catch {
+		return new Response("Invalid file request", { status: 400 });
+	}
+	const result = await dispatch(new FileBucket(input.bucketId), input);
+	if (result === void 0) return new Response(null, {
+		status: 204,
+		headers: { "Cache-Control": "no-store" }
+	});
+	return Response.json(result, { headers: { "Cache-Control": "private, no-store" } });
+};
+//#endregion
+//#region \0virtual:react-router/server-manifest
+var server_manifest_default = {
+	"entry": {
+		"module": "/assets/entry.client-Bc58m2-m.js",
+		"imports": ["/assets/jsx-runtime-eLCqVKHJ.js", "/assets/errorBoundaries-CQxPIuVU.js"],
+		"css": []
+	},
+	"routes": {
+		"root": {
+			"id": "root",
+			"parentId": void 0,
+			"path": "",
+			"index": void 0,
+			"caseSensitive": void 0,
+			"hasAction": false,
+			"hasLoader": false,
+			"hasClientAction": false,
+			"hasClientLoader": false,
+			"hasClientMiddleware": false,
+			"hasDefaultExport": true,
+			"hasErrorBoundary": true,
+			"module": "/assets/root-C1tmjS9o.js",
+			"imports": ["/assets/jsx-runtime-eLCqVKHJ.js", "/assets/errorBoundaries-CQxPIuVU.js"],
+			"css": ["/assets/root-BeNS6njP.css"],
+			"clientActionModule": void 0,
+			"clientLoaderModule": void 0,
+			"clientMiddlewareModule": void 0,
+			"hydrateFallbackModule": void 0
+		},
+		"routes/home": {
+			"id": "routes/home",
+			"parentId": "root",
+			"path": void 0,
+			"index": true,
+			"caseSensitive": void 0,
+			"hasAction": false,
+			"hasLoader": false,
+			"hasClientAction": false,
+			"hasClientLoader": false,
+			"hasClientMiddleware": false,
+			"hasDefaultExport": true,
+			"hasErrorBoundary": false,
+			"module": "/assets/home-CH2INc5e.js",
+			"imports": ["/assets/jsx-runtime-eLCqVKHJ.js"],
+			"css": [],
+			"clientActionModule": void 0,
+			"clientLoaderModule": void 0,
+			"clientMiddlewareModule": void 0,
+			"hydrateFallbackModule": void 0
+		},
+		"routes/files": {
+			"id": "routes/files",
+			"parentId": "root",
+			"path": "resources/files",
+			"index": void 0,
+			"caseSensitive": void 0,
+			"hasAction": true,
+			"hasLoader": false,
+			"hasClientAction": false,
+			"hasClientLoader": false,
+			"hasClientMiddleware": false,
+			"hasDefaultExport": false,
+			"hasErrorBoundary": false,
+			"module": "/assets/files-BvRk9kiK.js",
+			"imports": [],
+			"css": [],
+			"clientActionModule": void 0,
+			"clientLoaderModule": void 0,
+			"clientMiddlewareModule": void 0,
+			"hydrateFallbackModule": void 0
+		}
+	},
+	"url": "/assets/manifest-2d65dd0f.js",
+	"version": "2d65dd0f",
+	"sri": void 0
+};
+//#endregion
+//#region \0virtual:react-router/server-build
+var assetsBuildDirectory = "build/client";
+var basename = "/";
+var future = {
+	"unstable_enableNodeReadableStream": false,
+	"unstable_optimizeDeps": false
+};
+var ssr = true;
+var isSpaMode = false;
+var prerender = [];
+var routeDiscovery = {
+	"mode": "lazy",
+	"manifestPath": "/__manifest"
+};
+var publicPath = "/";
+var entry = { module: entry_server_node_exports };
+var routes = {
+	"root": {
+		id: "root",
+		parentId: void 0,
+		path: "",
+		index: void 0,
+		caseSensitive: void 0,
+		module: root_exports
+	},
+	"routes/home": {
+		id: "routes/home",
+		parentId: "root",
+		path: void 0,
+		index: true,
+		caseSensitive: void 0,
+		module: home_exports
+	},
+	"routes/files": {
+		id: "routes/files",
+		parentId: "root",
+		path: "resources/files",
+		index: void 0,
+		caseSensitive: void 0,
+		module: files_exports
+	}
+};
+var allowedActionOrigins = false;
+//#endregion
+export { allowedActionOrigins, server_manifest_default as assets, assetsBuildDirectory, basename, entry, future, isSpaMode, prerender, publicPath, routeDiscovery, routes, ssr };