docs-i18n 0.12.0 → 0.13.0

package/admin/dist/server/assets/request-response-Bj40K48O.js

@@ -0,0 +1,589 @@
+import { PassThrough, Readable } from "node:stream";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../../node_modules/.bun/rou3@0.8.1/node_modules/rou3/dist/index.mjs
+var NullProtoObj = /* @__PURE__ */ (() => {
+	const e = function() {};
+	return e.prototype = Object.create(null), Object.freeze(e.prototype), e;
+})();
+//#endregion
+//#region ../../node_modules/.bun/srvx@0.11.13/node_modules/srvx/dist/_chunks/_url.mjs
+function lazyInherit(target, source, sourceKey) {
+	for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
+		if (key === "constructor") continue;
+		const targetDesc = Object.getOwnPropertyDescriptor(target, key);
+		const desc = Object.getOwnPropertyDescriptor(source, key);
+		let modified = false;
+		if (desc.get) {
+			modified = true;
+			desc.get = targetDesc?.get || function() {
+				return this[sourceKey][key];
+			};
+		}
+		if (desc.set) {
+			modified = true;
+			desc.set = targetDesc?.set || function(value) {
+				this[sourceKey][key] = value;
+			};
+		}
+		if (!targetDesc?.value && typeof desc.value === "function") {
+			modified = true;
+			desc.value = function(...args) {
+				return this[sourceKey][key](...args);
+			};
+		}
+		if (modified) Object.defineProperty(target, key, desc);
+	}
+}
+var _needsNormRE = /(?:(?:^|\/)(?:\.|\.\.|%2e|%2e\.|\.%2e|%2e%2e)(?:\/|$))|[\\^\x80-\uffff]/i;
+/**
+* URL wrapper with fast paths to access to the following props:
+*
+*  - `url.pathname`
+*  - `url.search`
+*  - `url.searchParams`
+*  - `url.protocol`
+*
+* **NOTES:**
+*
+* - It is assumed that the input URL is **already encoded** and formatted from an HTTP request and contains no hash.
+* - Triggering the setters or getters on other props will deoptimize to full URL parsing.
+* - Changes to `searchParams` will be discarded as we don't track them.
+*/
+var FastURL = /* @__PURE__ */ (() => {
+	const NativeURL = globalThis.URL;
+	const FastURL = class URL {
+		#url;
+		#href;
+		#protocol;
+		#host;
+		#pathname;
+		#search;
+		#searchParams;
+		#pos;
+		constructor(url) {
+			if (typeof url === "string") if (url[0] === "/") this.#href = url;
+			else this.#url = new NativeURL(url);
+			else if (_needsNormRE.test(url.pathname)) this.#url = new NativeURL(`${url.protocol || "http:"}//${url.host || "localhost"}${url.pathname}${url.search || ""}`);
+			else {
+				this.#protocol = url.protocol;
+				this.#host = url.host;
+				this.#pathname = url.pathname;
+				this.#search = url.search;
+			}
+		}
+		static [Symbol.hasInstance](val) {
+			return val instanceof NativeURL;
+		}
+		get _url() {
+			if (this.#url) return this.#url;
+			this.#url = new NativeURL(this.href);
+			this.#href = void 0;
+			this.#protocol = void 0;
+			this.#host = void 0;
+			this.#pathname = void 0;
+			this.#search = void 0;
+			this.#searchParams = void 0;
+			this.#pos = void 0;
+			return this.#url;
+		}
+		get href() {
+			if (this.#url) return this.#url.href;
+			if (!this.#href) this.#href = `${this.#protocol || "http:"}//${this.#host || "localhost"}${this.#pathname || "/"}${this.#search || ""}`;
+			return this.#href;
+		}
+		#getPos() {
+			if (!this.#pos) {
+				const url = this.href;
+				const protoIndex = url.indexOf("://");
+				const pathnameIndex = protoIndex === -1 ? -1 : url.indexOf("/", protoIndex + 4);
+				this.#pos = [
+					protoIndex,
+					pathnameIndex,
+					pathnameIndex === -1 ? -1 : url.indexOf("?", pathnameIndex)
+				];
+			}
+			return this.#pos;
+		}
+		get pathname() {
+			if (this.#url) return this.#url.pathname;
+			if (this.#pathname === void 0) {
+				const [, pathnameIndex, queryIndex] = this.#getPos();
+				if (pathnameIndex === -1) return this._url.pathname;
+				this.#pathname = this.href.slice(pathnameIndex, queryIndex === -1 ? void 0 : queryIndex);
+			}
+			return this.#pathname;
+		}
+		get search() {
+			if (this.#url) return this.#url.search;
+			if (this.#search === void 0) {
+				const [, pathnameIndex, queryIndex] = this.#getPos();
+				if (pathnameIndex === -1) return this._url.search;
+				const url = this.href;
+				this.#search = queryIndex === -1 || queryIndex === url.length - 1 ? "" : url.slice(queryIndex);
+			}
+			return this.#search;
+		}
+		get searchParams() {
+			if (this.#url) return this.#url.searchParams;
+			if (!this.#searchParams) this.#searchParams = new URLSearchParams(this.search);
+			return this.#searchParams;
+		}
+		get protocol() {
+			if (this.#url) return this.#url.protocol;
+			if (this.#protocol === void 0) {
+				const [protocolIndex] = this.#getPos();
+				if (protocolIndex === -1) return this._url.protocol;
+				this.#protocol = this.href.slice(0, protocolIndex + 1);
+			}
+			return this.#protocol;
+		}
+		toString() {
+			return this.href;
+		}
+		toJSON() {
+			return this.href;
+		}
+	};
+	lazyInherit(FastURL.prototype, NativeURL.prototype, "_url");
+	Object.setPrototypeOf(FastURL.prototype, NativeURL.prototype);
+	Object.setPrototypeOf(FastURL, NativeURL);
+	return FastURL;
+})();
+//#endregion
+//#region ../../node_modules/.bun/srvx@0.11.13/node_modules/srvx/dist/adapters/node.mjs
+/**
+* Fast Response for Node.js runtime
+*
+* It is faster because in most cases it doesn't create a full Response instance.
+*/
+var NodeResponse = /* @__PURE__ */ (() => {
+	const NativeResponse = globalThis.Response;
+	const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+	class NodeResponse {
+		#body;
+		#init;
+		#headers;
+		#response;
+		constructor(body, init) {
+			this.#body = body;
+			this.#init = init;
+		}
+		static [Symbol.hasInstance](val) {
+			return val instanceof NativeResponse;
+		}
+		get status() {
+			return this.#response?.status || this.#init?.status || 200;
+		}
+		get statusText() {
+			return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
+		}
+		get headers() {
+			if (this.#response) return this.#response.headers;
+			if (this.#headers) return this.#headers;
+			const initHeaders = this.#init?.headers;
+			return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
+		}
+		get ok() {
+			if (this.#response) return this.#response.ok;
+			const status = this.status;
+			return status >= 200 && status < 300;
+		}
+		get _response() {
+			if (this.#response) return this.#response;
+			let body = this.#body;
+			if (body && typeof body.pipe === "function" && !(body instanceof Readable)) {
+				const stream = new PassThrough();
+				body.pipe(stream);
+				const abort = body.abort;
+				if (abort) stream.once("close", () => abort());
+				body = stream;
+			}
+			this.#response = new NativeResponse(body, this.#headers ? {
+				...this.#init,
+				headers: this.#headers
+			} : this.#init);
+			this.#init = void 0;
+			this.#headers = void 0;
+			this.#body = void 0;
+			return this.#response;
+		}
+		_toNodeResponse() {
+			const status = this.status;
+			const statusText = this.statusText;
+			let body;
+			let contentType;
+			let contentLength;
+			if (this.#response) body = this.#response.body;
+			else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
+			else if (typeof this.#body === "string") {
+				body = this.#body;
+				contentType = "text/plain; charset=UTF-8";
+				contentLength = Buffer.byteLength(this.#body);
+			} else if (this.#body instanceof ArrayBuffer) {
+				body = Buffer.from(this.#body);
+				contentLength = this.#body.byteLength;
+			} else if (this.#body instanceof Uint8Array) {
+				body = this.#body;
+				contentLength = this.#body.byteLength;
+			} else if (this.#body instanceof DataView) {
+				body = Buffer.from(this.#body.buffer);
+				contentLength = this.#body.byteLength;
+			} else if (this.#body instanceof Blob) {
+				body = this.#body.stream();
+				contentType = this.#body.type;
+				contentLength = this.#body.size;
+			} else if (typeof this.#body.pipe === "function") body = this.#body;
+			else body = this._response.body;
+			const headers = [];
+			const initHeaders = this.#init?.headers;
+			const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k, v]) => [k.toLowerCase(), v]) : void 0);
+			let hasContentTypeHeader;
+			let hasContentLength;
+			if (headerEntries) for (const [key, value] of headerEntries) {
+				if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
+				else headers.push([key, value]);
+				if (key === "content-type") hasContentTypeHeader = true;
+				else if (key === "content-length") hasContentLength = true;
+			}
+			if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
+			if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+			this.#init = void 0;
+			this.#headers = void 0;
+			this.#response = void 0;
+			this.#body = void 0;
+			return {
+				status,
+				statusText,
+				headers,
+				body
+			};
+		}
+	}
+	lazyInherit(NodeResponse.prototype, NativeResponse.prototype, "_response");
+	Object.setPrototypeOf(NodeResponse, NativeResponse);
+	Object.setPrototypeOf(NodeResponse.prototype, NativeResponse.prototype);
+	return NodeResponse;
+})();
+//#endregion
+//#region ../../node_modules/.bun/h3@2.0.1-rc.16/node_modules/h3/dist/h3-ByfIX5Jk.mjs
+var kEventNS = "h3.internal.event.";
+var kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
+var kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
+var H3Event = class {
+	app;
+	req;
+	url;
+	context;
+	static __is_event__ = true;
+	constructor(req, context, app) {
+		this.context = context || req.context || new NullProtoObj();
+		this.req = req;
+		this.app = app;
+		const _url = req._url;
+		this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+	}
+	get res() {
+		return this[kEventRes] ||= new H3EventResponse();
+	}
+	get runtime() {
+		return this.req.runtime;
+	}
+	waitUntil(promise) {
+		this.req.waitUntil?.(promise);
+	}
+	toString() {
+		return `[${this.req.method}] ${this.req.url}`;
+	}
+	toJSON() {
+		return this.toString();
+	}
+	get node() {
+		return this.req.runtime?.node;
+	}
+	get headers() {
+		return this.req.headers;
+	}
+	get path() {
+		return this.url.pathname + this.url.search;
+	}
+	get method() {
+		return this.req.method;
+	}
+};
+var H3EventResponse = class {
+	status;
+	statusText;
+	get headers() {
+		return this[kEventResHeaders] ||= new Headers();
+	}
+};
+var DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+	return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+	if (!statusCode) return defaultStatusCode;
+	if (typeof statusCode === "string") statusCode = +statusCode;
+	if (statusCode < 100 || statusCode > 599) return defaultStatusCode;
+	return statusCode;
+}
+var HTTPError = class HTTPError extends Error {
+	get name() {
+		return "HTTPError";
+	}
+	status;
+	statusText;
+	headers;
+	cause;
+	data;
+	body;
+	unhandled;
+	static isError(input) {
+		return input instanceof Error && input?.name === "HTTPError";
+	}
+	static status(status, statusText, details) {
+		return new HTTPError({
+			...details,
+			statusText,
+			status
+		});
+	}
+	constructor(arg1, arg2) {
+		let messageInput;
+		let details;
+		if (typeof arg1 === "string") {
+			messageInput = arg1;
+			details = arg2;
+		} else details = arg1;
+		const status = sanitizeStatusCode(details?.status || (details?.cause)?.status || details?.status || details?.statusCode, 500);
+		const statusText = sanitizeStatusMessage(details?.statusText || (details?.cause)?.statusText || details?.statusText || details?.statusMessage);
+		const message = messageInput || details?.message || (details?.cause)?.message || details?.statusText || details?.statusMessage || [
+			"HTTPError",
+			status,
+			statusText
+		].filter(Boolean).join(" ");
+		super(message, { cause: details });
+		this.cause = details;
+		this.status = status;
+		this.statusText = statusText || void 0;
+		const rawHeaders = details?.headers || (details?.cause)?.headers;
+		this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
+		this.unhandled = details?.unhandled ?? (details?.cause)?.unhandled ?? void 0;
+		this.data = details?.data;
+		this.body = details?.body;
+	}
+	get statusCode() {
+		return this.status;
+	}
+	get statusMessage() {
+		return this.statusText;
+	}
+	toJSON() {
+		const unhandled = this.unhandled;
+		return {
+			status: this.status,
+			statusText: this.statusText,
+			unhandled,
+			message: unhandled ? "HTTPError" : this.message,
+			data: unhandled ? void 0 : this.data,
+			...unhandled ? void 0 : this.body
+		};
+	}
+};
+function isJSONSerializable(value, _type) {
+	if (value === null || value === void 0) return true;
+	if (_type !== "object") return _type === "boolean" || _type === "number" || _type === "string";
+	if (typeof value.toJSON === "function") return true;
+	if (Array.isArray(value)) return true;
+	if (typeof value.pipe === "function" || typeof value.pipeTo === "function") return false;
+	if (value instanceof NullProtoObj) return true;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+var kNotFound = /* @__PURE__ */ Symbol.for("h3.notFound");
+var kHandled = /* @__PURE__ */ Symbol.for("h3.handled");
+function toResponse(val, event, config = {}) {
+	if (typeof val?.then === "function") return (val.catch?.((error) => error) || Promise.resolve(val)).then((resolvedVal) => toResponse(resolvedVal, event, config));
+	const response = prepareResponse(val, event, config);
+	if (typeof response?.then === "function") return toResponse(response, event, config);
+	const { onResponse } = config;
+	return onResponse ? Promise.resolve(onResponse(response, event)).then(() => response) : response;
+}
+var HTTPResponse = class {
+	#headers;
+	#init;
+	body;
+	constructor(body, init) {
+		this.body = body;
+		this.#init = init;
+	}
+	get status() {
+		return this.#init?.status || 200;
+	}
+	get statusText() {
+		return this.#init?.statusText || "OK";
+	}
+	get headers() {
+		return this.#headers ||= new Headers(this.#init?.headers);
+	}
+};
+function prepareResponse(val, event, config, nested) {
+	if (val === kHandled) return new NodeResponse(null);
+	if (val === kNotFound) val = new HTTPError({
+		status: 404,
+		message: `Cannot find any route matching [${event.req.method}] ${event.url}`
+	});
+	if (val && val instanceof Error) {
+		const isHTTPError = HTTPError.isError(val);
+		const error = isHTTPError ? val : new HTTPError(val);
+		if (!isHTTPError) {
+			error.unhandled = true;
+			if (val?.stack) error.stack = val.stack;
+		}
+		if (error.unhandled && !config.silent) console.error(error);
+		const { onError } = config;
+		return onError && !nested ? Promise.resolve(onError(error, event)).catch((error) => error).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
+	}
+	const preparedRes = event[kEventRes];
+	const preparedHeaders = preparedRes?.[kEventResHeaders];
+	event[kEventRes] = void 0;
+	if (!(val instanceof Response)) {
+		const res = prepareResponseBody(val, event, config);
+		const status = res.status || preparedRes?.status;
+		return new NodeResponse(nullBody(event.req.method, status) ? null : res.body, {
+			status,
+			statusText: res.statusText || preparedRes?.statusText,
+			headers: res.headers && preparedHeaders ? mergeHeaders$1(res.headers, preparedHeaders) : res.headers || preparedHeaders
+		});
+	}
+	if (!preparedHeaders || nested || !val.ok) return val;
+	try {
+		mergeHeaders$1(val.headers, preparedHeaders, val.headers);
+		return val;
+	} catch {
+		return new NodeResponse(nullBody(event.req.method, val.status) ? null : val.body, {
+			status: val.status,
+			statusText: val.statusText,
+			headers: mergeHeaders$1(val.headers, preparedHeaders)
+		});
+	}
+}
+function mergeHeaders$1(base, overrides, target = new Headers(base)) {
+	for (const [name, value] of overrides) if (name === "set-cookie") target.append(name, value);
+	else target.set(name, value);
+	return target;
+}
+var frozen = (name) => (...args) => {
+	throw new Error(`Headers are frozen (${name} ${args.join(", ")})`);
+};
+var FrozenHeaders = class extends Headers {
+	set = frozen("set");
+	append = frozen("append");
+	delete = frozen("delete");
+};
+var emptyHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-length": "0" });
+var jsonHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-type": "application/json;charset=UTF-8" });
+function prepareResponseBody(val, event, config) {
+	if (val === null || val === void 0) return {
+		body: "",
+		headers: emptyHeaders
+	};
+	const valType = typeof val;
+	if (valType === "string") return { body: val };
+	if (val instanceof Uint8Array) {
+		event.res.headers.set("content-length", val.byteLength.toString());
+		return { body: val };
+	}
+	if (val instanceof HTTPResponse || val?.constructor?.name === "HTTPResponse") return val;
+	if (isJSONSerializable(val, valType)) return {
+		body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
+		headers: jsonHeaders
+	};
+	if (valType === "bigint") return {
+		body: val.toString(),
+		headers: jsonHeaders
+	};
+	if (val instanceof Blob) {
+		const headers = new Headers({
+			"content-type": val.type,
+			"content-length": val.size.toString()
+		});
+		let filename = val.name;
+		if (filename) {
+			filename = encodeURIComponent(filename);
+			headers.set("content-disposition", `filename="${filename}"; filename*=UTF-8''${filename}`);
+		}
+		return {
+			body: val.stream(),
+			headers
+		};
+	}
+	if (valType === "symbol") return { body: val.toString() };
+	if (valType === "function") return { body: `${val.name}()` };
+	return { body: val };
+}
+function nullBody(method, status) {
+	return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
+}
+function errorResponse(error, debug) {
+	return new NodeResponse(JSON.stringify({
+		...error.toJSON(),
+		stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
+	}, void 0, debug ? 2 : void 0), {
+		status: error.status,
+		statusText: error.statusText,
+		headers: error.headers ? mergeHeaders$1(jsonHeaders, error.headers) : new Headers(jsonHeaders)
+	});
+}
+new TextEncoder();
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+start-server-core@1.167.3/node_modules/@tanstack/start-server-core/dist/esm/request-response.js
+var GLOBAL_EVENT_STORAGE_KEY = Symbol.for("tanstack-start:event-storage");
+var globalObj = globalThis;
+if (!globalObj[GLOBAL_EVENT_STORAGE_KEY]) globalObj[GLOBAL_EVENT_STORAGE_KEY] = new AsyncLocalStorage();
+var eventStorage = globalObj[GLOBAL_EVENT_STORAGE_KEY];
+function isPromiseLike(value) {
+	return typeof value.then === "function";
+}
+function getSetCookieValues(headers) {
+	const headersWithSetCookie = headers;
+	if (typeof headersWithSetCookie.getSetCookie === "function") return headersWithSetCookie.getSetCookie();
+	const value = headers.get("set-cookie");
+	return value ? [value] : [];
+}
+function mergeEventResponseHeaders(response, event) {
+	if (response.ok) return;
+	const eventSetCookies = getSetCookieValues(event.res.headers);
+	if (eventSetCookies.length === 0) return;
+	const responseSetCookies = getSetCookieValues(response.headers);
+	response.headers.delete("set-cookie");
+	for (const cookie of responseSetCookies) response.headers.append("set-cookie", cookie);
+	for (const cookie of eventSetCookies) response.headers.append("set-cookie", cookie);
+}
+function attachResponseHeaders(value, event) {
+	if (isPromiseLike(value)) return value.then((resolved) => {
+		if (resolved instanceof Response) mergeEventResponseHeaders(resolved, event);
+		return resolved;
+	});
+	if (value instanceof Response) mergeEventResponseHeaders(value, event);
+	return value;
+}
+function requestHandler(handler) {
+	return (request, requestOpts) => {
+		const h3Event = new H3Event(request);
+		return toResponse(attachResponseHeaders(eventStorage.run({ h3Event }, () => handler(request, requestOpts)), h3Event), h3Event);
+	};
+}
+function getH3Event() {
+	const event = eventStorage.getStore();
+	if (!event) throw new Error(`No StartEvent found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`);
+	return event.h3Event;
+}
+function getRequest() {
+	return getH3Event().req;
+}
+function getResponse() {
+	return getH3Event().res;
+}
+//#endregion
+export { getResponse as n, requestHandler as r, getRequest as t };

package/admin/dist/server/assets/{router-noqexgr0.js → router-B4k1eDGl.js}

@@ -1,8 +1,8 @@
 import { i as __toESM } from "./chunk-CNvmzFzq.js";
 import { l as require_react, r as require_jsx_runtime, t as useRouter } from "./useRouter-BXJvr8to.js";
-import { N as escapeHtml, j as deepEqual, r as useStore, s as useHydrated } from "./__tanstack-start-server-fn-resolver-D1Ni2lpa.js";
-import { A as skipToken, C as noop, D as resolveStaleTime, F as lazyRouteComponent, I as createFileRoute, L as createLazyFileRoute, N as focusManager, P as Subscribable, R as createRootRouteWithContext, S as matchQuery, _ as functionalUpdate, a as Mutation, g as ensureQueryFn, h as addToStart, l as onlineManager, m as addToEnd, p as addConsumeAwareSignal, r as QueryClientProvider, s as Query, t as Route$2, u as notifyManager, v as hashKey, w as partialMatchKey, x as matchMutation, y as hashQueryKeyByOptions } from "./routes-CLdSUfb7.js";
-import { c as getAssetCrossOrigin, d as createNonReactiveMutableStore, f as createNonReactiveReadonlyStore, i as Outlet, l as resolveManifestAssetLink, u as RouterCore } from "../server.js";
+import { N as escapeHtml, j as deepEqual, r as useStore, s as useHydrated } from "./__tanstack-start-server-fn-resolver-SG4WUVWE.js";
+import { d as RouterCore, h as createNonReactiveReadonlyStore, l as getAssetCrossOrigin, m as createNonReactiveMutableStore, n as Outlet, u as resolveManifestAssetLink } from "./Match-BeWrYoSG.js";
+import { A as skipToken, C as noop, D as resolveStaleTime, F as lazyRouteComponent, I as createFileRoute, L as createLazyFileRoute, N as focusManager, P as Subscribable, R as createRootRouteWithContext, S as matchQuery, _ as functionalUpdate, a as Mutation, g as ensureQueryFn, h as addToStart, l as onlineManager, m as addToEnd, p as addConsumeAwareSignal, r as QueryClientProvider, s as Query, t as Route$2, u as notifyManager, v as hashKey, w as partialMatchKey, x as matchMutation, y as hashQueryKeyByOptions } from "./routes-D0bCl8P2.js";
 //#endregion
 //#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/routerStores.js
 var getStoreFactory = (opts) => {
@@ -879,7 +879,7 @@ function RootDocument({ children }) {
 }
 //#endregion
 //#region app/routes/login.tsx
-var $$splitComponentImporter = () => import("./login-SqzTMYOZ.js");
+var $$splitComponentImporter = () => import("./login-BMn8hY2z.js");
 //#endregion
 //#region app/routeTree.gen.ts
 var LoginRoute = createFileRoute("/login")({ component: lazyRouteComponent($$splitComponentImporter, "component") }).update({

package/admin/dist/server/assets/{routes-CLdSUfb7.js → routes-D0bCl8P2.js}

@@ -1,8 +1,8 @@
 import { i as __toESM } from "./chunk-CNvmzFzq.js";
 import { a as useForwardedRef, i as reactUse, l as require_react, o as useIntersectionObserver, r as require_jsx_runtime, t as useRouter } from "./useRouter-BXJvr8to.js";
-import { B as replaceEqualDeep$1, E as invariant, F as isDangerousProtocol, I as isModuleNotFoundError, P as functionalUpdate$1, a as matchContext, c as rootRouteId, f as exactPathTest, h as removeTrailingSlash, i as dummyMatchContext, j as deepEqual, m as joinPaths, n as require_react_dom, r as useStore, s as useHydrated, t as getServerFnById, v as trimPathLeft, y as trimPathRight } from "./__tanstack-start-server-fn-resolver-D1Ni2lpa.js";
-import { t as useNavigate } from "./useNavigate-0H08s_Q2.js";
-import { n as TSS_SERVER_FUNCTION, p as redirect, t as createServerFn } from "../server.js";
+import { B as replaceEqualDeep$1, E as invariant, F as isDangerousProtocol, I as isModuleNotFoundError, P as functionalUpdate$1, a as matchContext, c as rootRouteId, f as exactPathTest, h as removeTrailingSlash, i as dummyMatchContext, j as deepEqual, m as joinPaths, n as require_react_dom, r as useStore, s as useHydrated, t as getServerFnById, v as trimPathLeft, y as trimPathRight } from "./__tanstack-start-server-fn-resolver-SG4WUVWE.js";
+import { g as redirect, t as createServerFn, u as TSS_SERVER_FUNCTION } from "./createServerFn-CAF9Kl7K.js";
+import { t as useNavigate } from "./useNavigate-CDLfQmZd.js";
 //#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/link.js
 var preloadWarning = "Error preloading route! ☝️";
 //#endregion
@@ -2107,13 +2107,9 @@ var createSsrRpc = (functionId, importer) => {
 * Protect the admin URL at the Cloudflare level if needed.
 */
 var getSession = createServerFn({ method: "GET" }).handler(createSsrRpc("539c27f871f75647d981e1ed4d82b5ee620e9e557722641a4a57c5a5818760c9"));
-/**
-* Seed a default admin user if none exists.
-* Only runs once per server lifetime.
-*/
 //#endregion
 //#region app/routes/index.tsx
-var $$splitComponentImporter = () => import("./routes-BG89QZ0_.js");
+var $$splitComponentImporter = () => import("./routes-ef6kOTX8.js");
 /**
 * Parse version keys into project/version structure.
 * Multi-project keys look like "query/v5", single-project keys look like "v5".

package/admin/dist/server/assets/{routes-BG89QZ0_.js → routes-ef6kOTX8.js}

@@ -1,9 +1,9 @@
 import { i as __toESM } from "./chunk-CNvmzFzq.js";
 import { l as require_react, r as require_jsx_runtime } from "./useRouter-BXJvr8to.js";
-import { C as noop, D as resolveStaleTime, E as resolveEnabled, M as timeoutManager, N as focusManager, O as shallowEqualObjects, P as Subscribable, T as replaceData, b as isValidTimeout, c as fetchState, d as pendingThenable, f as environmentManager, i as useQueryClient, j as timeUntilStale, k as shouldThrowError, n as createSsrRpc, o as getDefaultState, t as Route, u as notifyManager, v as hashKey } from "./routes-CLdSUfb7.js";
-import { t as useNavigate } from "./useNavigate-0H08s_Q2.js";
-import { t as createServerFn } from "../server.js";
-import { t as authClient } from "./auth-client-CoUpyQIM.js";
+import { t as createServerFn } from "./createServerFn-CAF9Kl7K.js";
+import { C as noop, D as resolveStaleTime, E as resolveEnabled, M as timeoutManager, N as focusManager, O as shallowEqualObjects, P as Subscribable, T as replaceData, b as isValidTimeout, c as fetchState, d as pendingThenable, f as environmentManager, i as useQueryClient, j as timeUntilStale, k as shouldThrowError, n as createSsrRpc, o as getDefaultState, t as Route, u as notifyManager, v as hashKey } from "./routes-D0bCl8P2.js";
+import { t as useNavigate } from "./useNavigate-CDLfQmZd.js";
+import { t as authClient } from "./auth-client-DZADgYlJ.js";
 //#region ../../node_modules/.bun/@tanstack+query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/queryObserver.js
 var QueryObserver = class extends Subscribable {
 	constructor(client, options) {

package/admin/dist/server/assets/{sqlite-adapter-CL2EidjD.js → sqlite-adapter-C24CHMIE.js}

@@ -1,4 +1,4 @@
-import { r as DefaultQueryCompiler } from "./migrator-ZpVZslbq.js";
+import { r as DefaultQueryCompiler } from "./migrator-6o36lk3A.js";
 //#region ../../node_modules/.bun/kysely@0.28.14/node_modules/kysely/dist/esm/dialect/dialect-adapter-base.js
 /**
 * A basic implementation of `DialectAdapter` with sensible default values.

package/admin/dist/server/assets/{status-BYF_y9fT.js → status-Bdrqzx_H.js}

@@ -1,4 +1,4 @@
-import { i as parseMdx, r as flattenSources, t as TranslationCache } from "./dist-BnKtYOU0.js";
+import { a as parseMdx, n as flattenSources, t as TranslationCache } from "./dist-3sjmTS6w.js";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 //#region server/services/status.ts
@@ -159,4 +159,4 @@ function getFileBlocks(version, lang, file) {
 	return blocks;
 }
 //#endregion
-export { getCache, getFileBlocks, getFileCoverage, getLangs, getOverview, getVersions, initStatus, rescan };
+export { getLangs as a, initStatus as c, getFileCoverage as i, rescan as l, getCache as n, getOverview as o, getFileBlocks as r, getVersions as s, ensureScanned as t };

package/admin/dist/server/assets/status-C_h82YTJ.js

@@ -0,0 +1,2 @@
+import { c as initStatus } from "./status-Bdrqzx_H.js";
+export { initStatus };