@hot-updater/console 0.36.6 → 1.0.0-rc.0

package/.output/server/_ssr/auth-BF8mbAgF.mjs

@@ -0,0 +1,21 @@
+//#region node_modules/.nitro/vite/services/ssr/assets/auth-BF8mbAgF.js
+var principal = {
+	email: "local@hot-updater.dev",
+	name: "Local Console"
+};
+var auth_default = {
+	async handle() {
+		return new Response("Not Found", { status: 404 });
+	},
+	async getAccess() {
+		return {
+			status: "authorized",
+			principal
+		};
+	},
+	async getProviders() {
+		return [];
+	}
+};
+//#endregion
+export { auth_default as default };

package/.output/server/_ssr/auth-rpc-BrJ6obHJ.mjs

@@ -0,0 +1,24 @@
+import { c as createServerFn } from "./createServerFn-B2hcXoPM.mjs";
+import { t as createServerRpc } from "./createServerRpc-DB29C_5p.mjs";
+import { r as getRequest } from "./server-BjzmvXnO.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/auth-rpc-BrJ6obHJ.js
+var getConsoleAccessRpc_createServerFn_handler = createServerRpc({
+	id: "c504696e68ba764b48c48aa8a40275938640941e473cf9cfdd7b2322d99f9d13",
+	name: "getConsoleAccessRpc",
+	filename: "src/lib/auth-rpc.ts"
+}, (opts) => getConsoleAccessRpc.__executeServer(opts));
+var getConsoleAccessRpc = createServerFn({ method: "GET" }).handler(getConsoleAccessRpc_createServerFn_handler, async () => {
+	const { getConsoleAccess } = await import("./auth.server-DwKoZoQM.mjs");
+	return getConsoleAccess(getRequest());
+});
+var getConsoleAuthProvidersRpc_createServerFn_handler = createServerRpc({
+	id: "fa8c48f0489d97c62b9b68fd0caf0a61b15bad25a42b3866ec36264b4b30bb74",
+	name: "getConsoleAuthProvidersRpc",
+	filename: "src/lib/auth-rpc.ts"
+}, (opts) => getConsoleAuthProvidersRpc.__executeServer(opts));
+var getConsoleAuthProvidersRpc = createServerFn({ method: "GET" }).handler(getConsoleAuthProvidersRpc_createServerFn_handler, async () => {
+	const { getConsoleAuthProviders } = await import("./auth.server-DwKoZoQM.mjs");
+	return getConsoleAuthProviders(getRequest());
+});
+//#endregion
+export { getConsoleAccessRpc_createServerFn_handler, getConsoleAuthProvidersRpc_createServerFn_handler };

package/.output/server/_ssr/auth.server-DwKoZoQM.mjs

@@ -0,0 +1,50 @@
+import path from "node:path";
+//#region node_modules/.nitro/vite/services/ssr/assets/auth.server-DwKoZoQM.js
+var readString = (value, key) => {
+	if (typeof value !== "object" || value === null) return void 0;
+	const member = Reflect.get(value, key);
+	return typeof member === "string" && member.trim().length > 0 ? member.trim() : void 0;
+};
+var getProviderName = (signing) => {
+	return readString(signing, "name")?.slice(0, 80) ?? (readString(signing, "privateKeyPath") ? "localSigning" : void 0) ?? "Configured provider";
+};
+var sanitizeConsoleSigningConfig = (signing) => {
+	if (typeof signing !== "object" || signing === null) return void 0;
+	const privateKeyPath = readString(signing, "privateKeyPath");
+	if (Reflect.get(signing, "enabled") === false || privateKeyPath && Reflect.get(signing, "enabled") !== true) return void 0;
+	const publicKeyPath = readString(signing, "publicKeyPath") ?? (privateKeyPath ? path.join(path.dirname(privateKeyPath), "public-key.pem") : void 0);
+	return {
+		enabled: true,
+		provider: getProviderName(signing),
+		...publicKeyPath === void 0 ? {} : { publicKeyPath }
+	};
+};
+var getConsoleAuthAdapter = async () => {
+	return (await import("./auth-BF8mbAgF.mjs")).default;
+};
+var resolveConsoleConfig = async (request) => {
+	const { default: source } = await import("./config-Dv8qLDZ0.mjs");
+	const { signing: signingSource, ...configWithoutSigning } = typeof source === "function" ? await source(request) : source;
+	const signing = sanitizeConsoleSigningConfig(signingSource);
+	return {
+		...configWithoutSigning,
+		...signing === void 0 ? {} : { signing }
+	};
+};
+var accessError = (access) => new Response(access.status === "unauthenticated" ? "Unauthorized" : "Forbidden", { status: access.status === "unauthenticated" ? 401 : 403 });
+var getConsoleAccess = async (request) => {
+	return (await getConsoleAuthAdapter()).getAccess(request);
+};
+var getConsoleAuthProviders = async (request) => {
+	return (await getConsoleAuthAdapter()).getProviders(request);
+};
+var handleConsoleAuth = async (request) => {
+	return (await getConsoleAuthAdapter()).handle(request);
+};
+var requireConsoleAccess = async (request) => {
+	const access = await getConsoleAccess(request);
+	if (access.status !== "authorized") throw accessError(access);
+	return access.principal;
+};
+//#endregion
+export { getConsoleAccess, getConsoleAuthProviders, handleConsoleAuth, requireConsoleAccess, resolveConsoleConfig as t };

package/.output/server/_ssr/badge-DCxbEeof.mjs

@@ -0,0 +1,26 @@
+import { nt as useRender, rt as mergeProps } from "../_libs/@base-ui/react+[...].mjs";
+import { t as cva } from "../_libs/class-variance-authority+clsx.mjs";
+import { C as cn } from "./createSsrRpc-9P0S0lJ3.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/badge-DCxbEeof.js
+var badgeVariants = cva("inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", {
+	variants: { variant: {
+		default: "border-transparent bg-primary text-primary-foreground shadow hover:bg-primary/80",
+		secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+		destructive: "border-transparent bg-destructive text-destructive-foreground shadow hover:bg-destructive/80",
+		outline: "text-foreground"
+	} },
+	defaultVariants: { variant: "default" }
+});
+function Badge({ className, variant = "default", render, ...props }) {
+	return useRender({
+		defaultTagName: "span",
+		props: mergeProps({ className: cn(badgeVariants({ variant }), className) }, props),
+		render,
+		state: {
+			slot: "badge",
+			variant
+		}
+	});
+}
+//#endregion
+export { Badge as t };

package/.output/server/_ssr/bundle-signing-rpc-COoQhW8E.mjs

@@ -0,0 +1,16 @@
+import { c as createServerFn } from "./createServerFn-B2hcXoPM.mjs";
+import { t as createServerRpc } from "./createServerRpc-DB29C_5p.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/bundle-signing-rpc-COoQhW8E.js
+var getBundleSigningInspection = async () => {
+	const [{ prepareConfig }, { inspectBundleSigning }] = await Promise.all([import("./config.server-DEiLhKmy.mjs"), import("./bundle-signing.server-D5u8KkMp.mjs")]);
+	const { config } = await prepareConfig();
+	return inspectBundleSigning(config.signing);
+};
+var getBundleSigningInspectionRpc_createServerFn_handler = createServerRpc({
+	id: "662034966679a6d29db2b55e7ba665e26e6c9a58a5529f33aa857a2049616233",
+	name: "getBundleSigningInspectionRpc",
+	filename: "src/lib/bundle-signing-rpc.ts"
+}, (opts) => getBundleSigningInspectionRpc.__executeServer(opts));
+var getBundleSigningInspectionRpc = createServerFn({ method: "GET" }).handler(getBundleSigningInspectionRpc_createServerFn_handler, getBundleSigningInspection);
+//#endregion
+export { getBundleSigningInspectionRpc_createServerFn_handler };

package/.output/server/_ssr/bundle-signing.server-D5u8KkMp.mjs

@@ -0,0 +1,51 @@
+import { createHash, createPublicKey } from "node:crypto";
+import path from "node:path";
+import { readFile, stat } from "node:fs/promises";
+//#region node_modules/.nitro/vite/services/ssr/assets/bundle-signing.server-D5u8KkMp.js
+var MAX_PUBLIC_KEY_BYTES = 16 * 1024;
+var DEFAULT_PROVIDER = "Configured provider";
+var PUBLIC_KEY_HEADER = "-----BEGIN PUBLIC KEY-----";
+var PUBLIC_KEY_FOOTER = "-----END PUBLIC KEY-----";
+var misconfigured = (provider, message) => ({
+	message,
+	provider,
+	status: "misconfigured"
+});
+var isSpkiPublicKeyPem = (value) => {
+	const trimmed = value.trim();
+	return trimmed.startsWith(PUBLIC_KEY_HEADER) && trimmed.endsWith(PUBLIC_KEY_FOOTER) && !trimmed.includes("PRIVATE KEY");
+};
+var inspectBundleSigning = async (signing) => {
+	if (!signing?.enabled) return { status: "disabled" };
+	const provider = signing.provider ?? DEFAULT_PROVIDER;
+	if (!signing.publicKeyPath) return misconfigured(provider, "A public key file is not configured.");
+	try {
+		const publicKeyPath = path.isAbsolute(signing.publicKeyPath) ? signing.publicKeyPath : path.resolve(process.cwd(), signing.publicKeyPath);
+		const publicKeyStat = await stat(publicKeyPath);
+		if (!publicKeyStat.isFile() || publicKeyStat.size > MAX_PUBLIC_KEY_BYTES) return misconfigured(provider, "The configured public key could not be loaded.");
+		const publicKeyPem = await readFile(publicKeyPath, "utf8");
+		if (!isSpkiPublicKeyPem(publicKeyPem)) return misconfigured(provider, "The configured public key is not a valid SPKI public key.");
+		const publicKey = createPublicKey(publicKeyPem);
+		if (publicKey.asymmetricKeyType !== "rsa") return misconfigured(provider, "The configured public key is not an RSA public key.");
+		if ((publicKey.asymmetricKeyDetails?.modulusLength ?? 0) < 2048) return misconfigured(provider, "The configured RSA public key must be at least 2048 bits.");
+		const canonicalDer = publicKey.export({
+			format: "der",
+			type: "spki"
+		});
+		const canonicalPem = publicKey.export({
+			format: "pem",
+			type: "spki"
+		});
+		return {
+			algorithm: "RSA-SHA256",
+			fingerprint: createHash("sha256").update(canonicalDer).digest("hex"),
+			provider,
+			publicKey: canonicalPem.toString().trim(),
+			status: "enabled"
+		};
+	} catch {
+		return misconfigured(provider, "The configured public key could not be loaded.");
+	}
+};
+//#endregion
+export { inspectBundleSigning };

package/.output/server/_ssr/config-Dv8qLDZ0.mjs

@@ -0,0 +1,13 @@
+import { loadConfig } from "@hot-updater/cli-tools";
+//#region node_modules/.nitro/vite/services/ssr/assets/config-Dv8qLDZ0.js
+var config_default = async () => {
+	const config = await loadConfig(null);
+	return {
+		console: { gitUrl: config.console.gitUrl },
+		database: config.database,
+		signing: config.signing,
+		storage: config.storage
+	};
+};
+//#endregion
+export { config_default as default };

package/.output/server/_ssr/config.server-DEiLhKmy.mjs

@@ -0,0 +1,361 @@
+import { l as getBundlePatches } from "./dist-BVSLTpoP.mjs";
+import { i as bundleToRow, n as bundleMetadataToRow, o as rowsToBundles, r as bundleToPatchRows, t as DatabasePluginInputError } from "./databaseRows-CwbNwYSl.mjs";
+import { r as getRequest } from "./server-BjzmvXnO.mjs";
+import { requireConsoleAccess, t as resolveConsoleConfig } from "./auth.server-DwKoZoQM.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/config.server-DEiLhKmy.js
+/**
+* Calculate pagination information based on total count, limit, and offset
+*/
+function calculatePagination(total, options) {
+	const { limit, offset } = options;
+	if (total === 0) return {
+		total: 0,
+		hasNextPage: false,
+		hasPreviousPage: false,
+		currentPage: 1,
+		totalPages: 0
+	};
+	const currentPage = Math.floor(offset / limit) + 1;
+	const totalPages = Math.ceil(total / limit);
+	return {
+		total,
+		hasNextPage: offset + limit < total,
+		hasPreviousPage: offset > 0,
+		currentPage,
+		totalPages
+	};
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var validateBundlePagination = (options) => {
+	if (!Number.isSafeInteger(options.limit) || options.limit <= 0 || options.page !== void 0 && (!Number.isSafeInteger(options.page) || options.page <= 0) || options.page !== void 0 && options.cursor !== void 0) throw new DatabasePluginInputError("invalid-pagination");
+	const cursor = options.cursor;
+	if (cursor === void 0) return;
+	if (!isRecord(cursor)) throw new DatabasePluginInputError("invalid-pagination");
+	const hasAfter = Object.hasOwn(cursor, "after");
+	if (hasAfter === Object.hasOwn(cursor, "before")) throw new DatabasePluginInputError("invalid-pagination");
+	const value = hasAfter ? cursor.after : cursor.before;
+	if (typeof value !== "string" || value.length === 0) throw new DatabasePluginInputError("invalid-pagination");
+};
+var DatabaseAtomicCommitUnsupportedError = class extends Error {
+	name = "DatabaseAtomicCommitUnsupportedError";
+	constructor(pluginName) {
+		super(`Database plugin "${pluginName}" cannot atomically commit changes across models.`);
+		this.pluginName = pluginName;
+	}
+};
+/**
+* Internal provider signal for a delete rejected by a live reference.
+*
+* Provider implementations throw this after translating their native
+* foreign-key or reference-condition error. The public database contract
+* observes only the indexed `referenced` commit conflict.
+*/
+var DatabaseRowReferencedError = class extends Error {
+	name = "DatabaseRowReferencedError";
+	constructor() {
+		super("The database row is still referenced.");
+	}
+};
+function assertStorageOperations(plugin, operations) {
+	for (const operation of operations) if (typeof plugin[operation] !== "function") throw new Error(`Storage plugin "${plugin.name}" does not implement ${operation}.`);
+}
+var DatabasePatchUpdateUnsupportedError = class extends Error {
+	name = "DatabasePatchUpdateUnsupportedError";
+	constructor(bundleId, pluginName) {
+		super(`Database plugin "${pluginName}" cannot atomically replace patches for bundle "${bundleId}".`);
+		this.bundleId = bundleId;
+		this.pluginName = pluginName;
+	}
+};
+var bundleUpdateToRow = (update, _channelId) => {
+	return {
+		...update.platform !== void 0 ? { platform: update.platform } : {},
+		...update.fileHash !== void 0 ? { file_hash: update.fileHash } : {},
+		...update.gitCommitHash !== void 0 ? { git_commit_hash: update.gitCommitHash } : {},
+		...update.storageUri !== void 0 ? { storage_uri: update.storageUri } : {},
+		...update.archiveByteSize !== void 0 ? { archive_byte_size: update.archiveByteSize } : {},
+		...update.metadata !== void 0 ? { metadata: bundleMetadataToRow(update.metadata) } : {},
+		...update.manifestStorageUri !== void 0 ? { manifest_storage_uri: update.manifestStorageUri } : {},
+		...update.manifestFileHash !== void 0 ? { manifest_file_hash: update.manifestFileHash } : {},
+		...update.assetBaseStorageUri !== void 0 ? { asset_base_storage_uri: update.assetBaseStorageUri } : {}
+	};
+};
+var bundleUpdateToPatchRows = (bundleId, update) => getBundlePatches({ patches: update.patches }).map((patch, orderIndex) => ({
+	id: `${bundleId}:${patch.baseBundleId}`,
+	bundle_id: bundleId,
+	base_bundle_id: patch.baseBundleId,
+	base_file_hash: patch.baseFileHash,
+	patch_file_hash: patch.patchFileHash,
+	patch_storage_uri: patch.patchStorageUri,
+	byte_size: patch.byteSize,
+	order_index: orderIndex
+}));
+var PAGE_SIZE = 100;
+var mergeIdFilter = (where, id) => ({
+	...where,
+	id: {
+		...where?.id,
+		...id
+	}
+});
+var loadBundleRows = async (database, where) => {
+	const finiteIds = where?.id?.in;
+	if (finiteIds) {
+		if (finiteIds.length === 0) return [];
+		return [...await database.models.bundles.findMany({
+			where,
+			limit: finiteIds.length,
+			offset: 0,
+			orderBy: {
+				field: "id",
+				direction: "asc"
+			}
+		})];
+	}
+	const [cutoff] = await database.models.bundles.findMany({
+		where,
+		limit: 1,
+		offset: 0,
+		orderBy: {
+			field: "id",
+			direction: "desc"
+		}
+	});
+	if (!cutoff) return [];
+	const rows = [];
+	let after;
+	for (;;) {
+		const page = await database.models.bundles.findMany({
+			where: mergeIdFilter(where, {
+				lte: cutoff.id,
+				...after ? { gt: after } : {}
+			}),
+			limit: PAGE_SIZE,
+			offset: 0,
+			orderBy: {
+				field: "id",
+				direction: "asc"
+			}
+		});
+		rows.push(...page);
+		if (page.length < PAGE_SIZE) return rows;
+		after = page.at(-1)?.id;
+	}
+};
+var hydrateRows = async (database, ownerRows) => {
+	const patchRows = await database.models.bundlePatches.findByBundleIds(ownerRows.map(({ id }) => id));
+	const ownerIds = new Set(ownerRows.map(({ id }) => id));
+	const referencedIds = [...new Set(patchRows.map(({ base_bundle_id }) => base_bundle_id).filter((id) => !ownerIds.has(id)))];
+	return rowsToBundles(ownerRows, patchRows, referencedIds.length === 0 ? [] : await loadBundleRows(database, { id: { in: referencedIds } }));
+};
+var cursorIdFilter = (cursor, direction) => {
+	if (cursor?.after) return { [direction === "desc" ? "lt" : "gt"]: cursor.after };
+	if (cursor?.before) return { [direction === "desc" ? "gt" : "lt"]: cursor.before };
+};
+var responsePage = async (database, options) => {
+	validateBundlePagination(options);
+	const direction = options.orderBy?.direction ?? "desc";
+	const offset = options.page ? Math.max(0, options.page - 1) * options.limit : 0;
+	const cursor = options.page ? void 0 : options.cursor;
+	const queryLimit = cursor ? options.limit + 1 : options.limit;
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(queryLimit) || !Number.isSafeInteger(offset + queryLimit)) throw new DatabasePluginInputError("invalid-pagination");
+	const cursorFilter = cursorIdFilter(cursor, direction);
+	const where = cursorFilter ? mergeIdFilter(options.where, cursorFilter) : options.where;
+	const queryDirection = cursor?.before ? direction === "desc" ? "asc" : "desc" : direction;
+	const [queriedRows, total] = await Promise.all([database.models.bundles.findMany({
+		where,
+		limit: queryLimit,
+		offset,
+		orderBy: {
+			field: "id",
+			direction: queryDirection
+		}
+	}), database.models.bundles.count(options.where)]);
+	const hasMore = cursor ? queriedRows.length > options.limit : false;
+	const pageRows = cursor ? queriedRows.slice(0, options.limit) : queriedRows;
+	const ownerRows = cursor?.before ? pageRows.toReversed() : pageRows;
+	const pagination = calculatePagination(total, {
+		limit: options.limit,
+		offset
+	});
+	const hasPreviousPage = cursor ? Boolean(cursor.after) || hasMore : pagination.hasPreviousPage;
+	const hasNextPage = cursor ? Boolean(cursor.before) || hasMore : pagination.hasNextPage;
+	const firstId = ownerRows[0]?.id;
+	const lastId = ownerRows.at(-1)?.id;
+	return {
+		data: await hydrateRows(database, ownerRows),
+		pagination: {
+			...pagination,
+			hasNextPage,
+			hasPreviousPage,
+			...hasNextPage && lastId ? { nextCursor: lastId } : {},
+			...hasPreviousPage && firstId ? { previousCursor: firstId } : {},
+			...!firstId && cursor?.after ? { previousCursor: cursor.after } : {},
+			...!lastId && cursor?.before ? { nextCursor: cursor.before } : {}
+		}
+	};
+};
+var DatabaseBundleNotFoundError = class extends Error {
+	name = "DatabaseBundleNotFoundError";
+	constructor(bundleId) {
+		super(`Bundle "${bundleId}" was not found.`);
+		this.bundleId = bundleId;
+	}
+};
+var DatabasePatchInsertUnsupportedError = class extends Error {
+	name = "DatabasePatchInsertUnsupportedError";
+	constructor(bundleId, pluginName) {
+		super(`Database plugin "${pluginName}" cannot atomically insert patches for bundle "${bundleId}".`);
+		this.bundleId = bundleId;
+		this.pluginName = pluginName;
+	}
+};
+var insertChanges = (bundle) => [{
+	model: "bundles",
+	operation: "insert",
+	row: bundleToRow(bundle)
+}, ...bundleToPatchRows(bundle).map((row) => ({
+	model: "bundlePatches",
+	operation: "insert",
+	row
+}))];
+var updateChanges = (bundleId, update) => {
+	const rowUpdate = bundleUpdateToRow(update);
+	return [{
+		model: "bundles",
+		operation: "update",
+		where: { id: bundleId },
+		update: rowUpdate
+	}, ...Object.hasOwn(update, "patches") ? [{
+		model: "bundlePatches",
+		operation: "delete",
+		where: { bundleId }
+	}, ...bundleUpdateToPatchRows(bundleId, update).map((row) => ({
+		model: "bundlePatches",
+		operation: "insert",
+		row
+	}))] : []];
+};
+var deleteChanges = (bundleId) => [{
+	model: "bundles",
+	operation: "delete",
+	where: { id: bundleId }
+}];
+var createDatabaseClient = (plugin) => {
+	const getBundleById = async (id) => {
+		const row = await plugin.models.bundles.findById(id);
+		if (!row) return null;
+		return (await hydrateRows(plugin, [row]))[0] ?? null;
+	};
+	const insertChannel = (input) => plugin.models.channels.insert(input);
+	const createMutationClient = (commit) => ({
+		getBundleById,
+		getBundles: (options) => responsePage(plugin, options),
+		async getChannels() {
+			return (await plugin.models.channels.list({})).channels;
+		},
+		insertChannel,
+		async insertBundle(bundle) {
+			try {
+				await commit(insertChanges(bundle));
+			} catch (error) {
+				if (error instanceof DatabaseAtomicCommitUnsupportedError && bundleToPatchRows(bundle).length > 0) throw new DatabasePatchInsertUnsupportedError(bundle.id, plugin.name);
+				throw error;
+			}
+		},
+		async updateBundleById(bundleId, update) {
+			try {
+				if (!(await commit(updateChanges(bundleId, update))).committed) throw new DatabaseBundleNotFoundError(bundleId);
+			} catch (error) {
+				if (error instanceof DatabaseAtomicCommitUnsupportedError && Object.hasOwn(update, "patches")) throw new DatabasePatchUpdateUnsupportedError(bundleId, plugin.name);
+				throw error;
+			}
+		},
+		async deleteBundleById(bundleId) {
+			const result = await commit(deleteChanges(bundleId));
+			if (!result.committed && result.conflict.reason === "referenced") throw new DatabaseRowReferencedError();
+		}
+	});
+	const runMutation = async (operation) => {
+		const changes = [];
+		const result = await operation(createMutationClient(async (input) => {
+			changes.push(...input);
+			return { committed: true };
+		}));
+		if (changes.length === 0) return result;
+		const commitResult = await plugin.commit({ changes });
+		if (!commitResult.committed) {
+			const change = changes[commitResult.conflict.changeIndex];
+			if (commitResult.conflict.reason === "referenced" && change?.model === "bundles" && change.operation === "delete") throw new DatabaseRowReferencedError();
+			if (change?.model === "bundles" && change.operation === "update") throw new DatabaseBundleNotFoundError(change.where.id);
+			throw new Error(`Database plugin "${plugin.name}" rejected a commit.`);
+		}
+		return result;
+	};
+	return {
+		...createMutationClient((changes) => plugin.commit({ changes })),
+		deleteChannel: (input) => plugin.models.channels.delete(input),
+		mutate: runMutation
+	};
+};
+var configPromise = null;
+var databaseClient = null;
+var hotUpdater = null;
+var apiKeyStore = null;
+var apiKeyStoreResolved = false;
+var storagePluginPromise = null;
+var loadCachedConfig = async (request) => {
+	if (!configPromise) configPromise = resolveConsoleConfig(request).then((config) => ({
+		...config,
+		console: config.console ?? {}
+	})).catch((error) => {
+		configPromise = null;
+		throw error;
+	});
+	return configPromise;
+};
+var loadCachedStoragePlugin = async (config) => {
+	if (!storagePluginPromise) storagePluginPromise = Promise.resolve(config.storage).then((storagePlugin) => {
+		assertStorageOperations(storagePlugin, [
+			"get",
+			"put",
+			"exists",
+			"delete"
+		]);
+		return storagePlugin;
+	}).catch((error) => {
+		storagePluginPromise = null;
+		throw error;
+	});
+	return storagePluginPromise;
+};
+var prepareConfig = async (request = getRequest()) => {
+	try {
+		await requireConsoleAccess(request);
+		const config = await loadCachedConfig(request);
+		if (!databaseClient) databaseClient = createDatabaseClient(config.database);
+		if (!hotUpdater) {
+			const { createRuntimeHotUpdater } = await import("./runtime.server-awTLiiXW.mjs");
+			hotUpdater = createRuntimeHotUpdater(config);
+		}
+		if (!apiKeyStoreResolved) {
+			const { createApiKeyStore } = await import("./runtime.server-awTLiiXW.mjs");
+			apiKeyStore = createApiKeyStore(config);
+			apiKeyStoreResolved = true;
+		}
+		const storagePlugin = await loadCachedStoragePlugin(config);
+		return {
+			config,
+			databaseClient,
+			hotUpdater,
+			apiKeyStore,
+			storagePlugin
+		};
+	} catch (error) {
+		if (!(error instanceof Response && (error.status === 401 || error.status === 403))) console.error("Error during configuration initialization:", error);
+		throw error;
+	}
+};
+var isConfigLoaded = () => Boolean(configPromise);
+//#endregion
+export { isConfigLoaded, prepareConfig };

package/.output/server/_ssr/{createServerFn-DzU0k62V.mjs → createServerFn-B2hcXoPM.mjs}

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-//#region node_modules/.nitro/vite/services/ssr/assets/createServerFn-DzU0k62V.js
+//#region node_modules/.nitro/vite/services/ssr/assets/createServerFn-B2hcXoPM.js
 /**
 * Create a redirect Response understood by TanStack Router.
 *

package/.output/server/_ssr/createServerRpc-DB29C_5p.mjs

@@ -0,0 +1,12 @@
+import { i as TSS_SERVER_FUNCTION } from "./createServerFn-B2hcXoPM.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/createServerRpc-DB29C_5p.js
+var createServerRpc = (serverFnMeta, splitImportFn) => {
+	const url = "/_serverFn/" + serverFnMeta.id;
+	return Object.assign(splitImportFn, {
+		url,
+		serverFnMeta,
+		[TSS_SERVER_FUNCTION]: true
+	});
+};
+//#endregion
+export { createServerRpc as t };