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

package/.output/server/_ssr/dist-BVSLTpoP.mjs

@@ -0,0 +1,250 @@
+//#region node_modules/.nitro/vite/services/ssr/assets/dist-BVSLTpoP.js
+var stripBundleArtifactMetadata = (metadata) => metadata;
+var getManifestStorageUri = (bundle) => bundle.manifestStorageUri ?? null;
+var getManifestFileHash = (bundle) => bundle.manifestFileHash ?? null;
+var getAssetBaseStorageUri = (bundle) => bundle.assetBaseStorageUri ?? null;
+var isBundlePatchArtifact = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const candidate = value;
+	return typeof candidate.baseBundleId === "string" && typeof candidate.baseFileHash === "string" && typeof candidate.patchFileHash === "string" && typeof candidate.patchStorageUri === "string";
+};
+var readBundlePatchArray = (patches) => {
+	if (!Array.isArray(patches)) return [];
+	return patches.filter(isBundlePatchArtifact);
+};
+var getBundlePatches = (bundle) => {
+	const patches = readBundlePatchArray(bundle.patches);
+	const seenBaseBundleIds = /* @__PURE__ */ new Set();
+	return patches.filter((patch) => {
+		if (seenBaseBundleIds.has(patch.baseBundleId)) return false;
+		seenBaseBundleIds.add(patch.baseBundleId);
+		return true;
+	});
+};
+var getPrimaryPatch = (bundle) => {
+	return getBundlePatches(bundle)[0] ?? null;
+};
+var getPatchBaseBundleId = (bundle) => getPrimaryPatch(bundle)?.baseBundleId ?? null;
+var getPatchBaseFileHash = (bundle) => getPrimaryPatch(bundle)?.baseFileHash ?? null;
+var getPatchFileHash = (bundle) => getPrimaryPatch(bundle)?.patchFileHash ?? null;
+var getPatchStorageUri = (bundle) => getPrimaryPatch(bundle)?.patchStorageUri ?? null;
+var NUMERIC_COHORT_SIZE = 1e3;
+var DEFAULT_ROLLOUT_COHORT_COUNT = NUMERIC_COHORT_SIZE;
+var INVALID_COHORT_ERROR_MESSAGE = `Invalid cohort. Use 1-1000 or a lowercase slug without spaces, up to 64 characters.`;
+var CUSTOM_COHORT_PATTERN = /^[a-z0-9-]+$/;
+function parseNumericCohortValue(cohort) {
+	if (!/^\d+$/.test(cohort)) return null;
+	const parsed = Number.parseInt(cohort, 10);
+	if (Number.isNaN(parsed) || parsed < 1 || parsed > 1e3) return null;
+	return parsed;
+}
+function positiveMod(value, modulus) {
+	return (value % modulus + modulus) % modulus;
+}
+function hashString(value) {
+	let hash = 0;
+	for (let i = 0; i < value.length; i++) {
+		const char = value.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash |= 0;
+	}
+	return hash;
+}
+function gcd(a, b) {
+	let x = Math.abs(a);
+	let y = Math.abs(b);
+	while (y !== 0) {
+		const next = x % y;
+		x = y;
+		y = next;
+	}
+	return x;
+}
+function modularInverse(value, modulus) {
+	let t = 0;
+	let newT = 1;
+	let r = modulus;
+	let newR = positiveMod(value, modulus);
+	while (newR !== 0) {
+		const quotient = Math.floor(r / newR);
+		[t, newT] = [newT, t - quotient * newT];
+		[r, newR] = [newR, r - quotient * newR];
+	}
+	if (r > 1) throw new Error(`No modular inverse for ${value} mod ${modulus}`);
+	return positiveMod(t, modulus);
+}
+function getRolloutShuffleParameters(bundleId) {
+	let multiplier = positiveMod(hashString(`${bundleId}:multiplier`), 997);
+	if (multiplier === 0) multiplier = 1;
+	while (gcd(multiplier, NUMERIC_COHORT_SIZE) !== 1) {
+		multiplier = positiveMod(multiplier + 1, NUMERIC_COHORT_SIZE);
+		if (multiplier === 0) multiplier = 1;
+	}
+	const offset = positiveMod(hashString(`${bundleId}:offset`), NUMERIC_COHORT_SIZE);
+	return {
+		multiplier,
+		offset,
+		inverseMultiplier: modularInverse(multiplier, NUMERIC_COHORT_SIZE)
+	};
+}
+function normalizeRolloutCohortCount(rolloutCohortCount) {
+	if (rolloutCohortCount === null || rolloutCohortCount === void 0) return DEFAULT_ROLLOUT_COHORT_COUNT;
+	if (rolloutCohortCount <= 0) return 0;
+	if (rolloutCohortCount >= 1e3) return NUMERIC_COHORT_SIZE;
+	return Math.floor(rolloutCohortCount);
+}
+function normalizeCohortValue(cohort) {
+	const normalized = cohort.trim().toLowerCase();
+	const numericCohort = parseNumericCohortValue(normalized);
+	if (numericCohort !== null) return String(numericCohort);
+	return normalized;
+}
+function getNumericCohortValue(cohort) {
+	return parseNumericCohortValue(normalizeCohortValue(cohort));
+}
+function isNumericCohort(cohort) {
+	return getNumericCohortValue(cohort) !== null;
+}
+function isCustomCohort(cohort) {
+	const normalized = normalizeCohortValue(cohort);
+	return normalized.length > 0 && normalized.length <= 64 && !/^\d+$/.test(normalized) && CUSTOM_COHORT_PATTERN.test(normalized);
+}
+function isValidCohort(cohort) {
+	const normalized = normalizeCohortValue(cohort);
+	return isNumericCohort(normalized) || isCustomCohort(normalized);
+}
+function getNumericCohortRolloutPosition(bundleId, cohortValue) {
+	if (cohortValue < 1 || cohortValue > 1e3) throw new Error(`Invalid numeric cohort: ${cohortValue}`);
+	const { offset, inverseMultiplier } = getRolloutShuffleParameters(bundleId);
+	return positiveMod(inverseMultiplier * (cohortValue - 1 - offset), NUMERIC_COHORT_SIZE);
+}
+function getRolledOutNumericCohorts(bundleId, rolloutCohortCount) {
+	const normalizedRolloutCount = normalizeRolloutCohortCount(rolloutCohortCount);
+	if (normalizedRolloutCount <= 0) return [];
+	if (normalizedRolloutCount >= 1e3) return Array.from({ length: NUMERIC_COHORT_SIZE }, (_, index) => index + 1);
+	const { multiplier, offset } = getRolloutShuffleParameters(bundleId);
+	return Array.from({ length: normalizedRolloutCount }, (_, position) => positiveMod(multiplier * position + offset, NUMERIC_COHORT_SIZE)).map((zeroBasedCohort) => zeroBasedCohort + 1).sort((left, right) => left - right);
+}
+function isCohortEligibleForUpdate(bundleId, cohort, rolloutCohortCount, targetCohorts) {
+	const normalizedCohort = cohort === null || cohort === void 0 ? void 0 : normalizeCohortValue(cohort);
+	const normalizedTargetCohorts = targetCohorts?.map((targetCohort) => normalizeCohortValue(targetCohort)) ?? [];
+	if (normalizedCohort !== void 0 && normalizedTargetCohorts.includes(normalizedCohort)) return true;
+	const normalizedRolloutCount = normalizeRolloutCohortCount(rolloutCohortCount);
+	if (normalizedRolloutCount <= 0) return false;
+	if (normalizedCohort === void 0) return normalizedRolloutCount >= NUMERIC_COHORT_SIZE;
+	const numericCohort = getNumericCohortValue(normalizedCohort);
+	if (numericCohort === null) return false;
+	if (normalizedRolloutCount >= 1e3) return true;
+	return getNumericCohortRolloutPosition(bundleId, numericCohort) < normalizedRolloutCount;
+}
+var RELEASE_CATALOG_FALLBACK_POLICY = "BUILTIN_IF_ACTIVE_INELIGIBLE";
+var MAX_COMPILED_CATALOG_BYTES = 256 * 1024;
+function isReleaseEligibleForCohort(release, cohort) {
+	if (isCohortEligibleForUpdate(release.releaseId, cohort, release.rolloutCohortCount, release.targetCohorts)) return true;
+	return cohort !== null && cohort !== void 0 && isCustomCohort(normalizeCohortValue(cohort)) && normalizeRolloutCohortCount(release.rolloutCohortCount) === 1e3;
+}
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var MAX_CATALOG_SEGMENT_LENGTH = 255;
+function assertCatalogSegment(value, name) {
+	if (value.length === 0 || value.length > MAX_CATALOG_SEGMENT_LENGTH || !/^[A-Za-z0-9._~-]+$/.test(value)) throw new Error(`${name} must be 1-${MAX_CATALOG_SEGMENT_LENGTH} URL-safe ASCII characters`);
+}
+function encodeUtf8(value) {
+	const bytes = [];
+	for (const codePointText of value) {
+		const codePoint = codePointText.codePointAt(0);
+		if (codePoint <= 127) bytes.push(codePoint);
+		else if (codePoint <= 2047) bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
+		else if (codePoint <= 65535) bytes.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+		else bytes.push(240 | codePoint >> 18, 128 | codePoint >> 12 & 63, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+	}
+	return bytes;
+}
+function decodeUtf8(bytes) {
+	let result = "";
+	for (let index = 0; index < bytes.length;) {
+		const first = bytes[index++];
+		let codePoint;
+		let continuationCount;
+		if (first <= 127) {
+			codePoint = first;
+			continuationCount = 0;
+		} else if ((first & 224) === 192) {
+			codePoint = first & 31;
+			continuationCount = 1;
+		} else if ((first & 240) === 224) {
+			codePoint = first & 15;
+			continuationCount = 2;
+		} else if ((first & 248) === 240) {
+			codePoint = first & 7;
+			continuationCount = 3;
+		} else throw new Error("Invalid UTF-8 channel key");
+		for (let offset = 0; offset < continuationCount; offset += 1) {
+			const continuation = bytes[index++];
+			if (continuation === void 0 || (continuation & 192) !== 128) throw new Error("Invalid UTF-8 channel key");
+			codePoint = codePoint << 6 | continuation & 63;
+		}
+		if (codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 || continuationCount === 1 && codePoint < 128 || continuationCount === 2 && codePoint < 2048 || continuationCount === 3 && codePoint < 65536) throw new Error("Invalid UTF-8 channel key");
+		result += String.fromCodePoint(codePoint);
+	}
+	return result;
+}
+function base64UrlEncode(bytes) {
+	let result = "";
+	for (let index = 0; index < bytes.length; index += 3) {
+		const first = bytes[index];
+		const second = bytes[index + 1];
+		const third = bytes[index + 2];
+		const value = first << 16 | (second ?? 0) << 8 | (third ?? 0);
+		result += BASE64URL_ALPHABET[value >> 18 & 63];
+		result += BASE64URL_ALPHABET[value >> 12 & 63];
+		if (second !== void 0) result += BASE64URL_ALPHABET[value >> 6 & 63];
+		if (third !== void 0) result += BASE64URL_ALPHABET[value & 63];
+	}
+	return result;
+}
+function base64UrlDecode(value) {
+	if (!/^[A-Za-z0-9_-]*$/.test(value) || value.length % 4 === 1) throw new Error("Invalid channel key");
+	const bytes = [];
+	for (let index = 0; index < value.length; index += 4) {
+		const chunk = value.slice(index, index + 4);
+		const encoded = [...chunk].map((character) => BASE64URL_ALPHABET.indexOf(character));
+		if (encoded.some((part) => part < 0)) throw new Error("Invalid channel key");
+		const bits = encoded[0] << 18 | encoded[1] << 12 | (encoded[2] ?? 0) << 6 | (encoded[3] ?? 0);
+		bytes.push(bits >> 16 & 255);
+		if (chunk.length >= 3) bytes.push(bits >> 8 & 255);
+		if (chunk.length === 4) bytes.push(bits & 255);
+	}
+	return bytes;
+}
+function normalizeChannelName(channel) {
+	return channel.trim().normalize("NFC");
+}
+function assertCanonicalChannelName(channel) {
+	const normalized = normalizeChannelName(channel);
+	if (normalized.length === 0 || normalized !== channel) throw new Error("Channel name must be non-empty, trimmed, and NFC-normalized");
+	let codePointCount = 0;
+	for (const _codePoint of normalized) {
+		codePointCount += 1;
+		if (codePointCount > 255) throw new Error("Channel name must not exceed 255 characters");
+	}
+}
+function encodeChannelKey(channel) {
+	assertCanonicalChannelName(channel);
+	return base64UrlEncode(encodeUtf8(channel));
+}
+function decodeChannelKey(channelKey) {
+	const channel = decodeUtf8(base64UrlDecode(channelKey));
+	assertCanonicalChannelName(channel);
+	if (encodeChannelKey(channel) !== channelKey) throw new Error("Channel key is not canonically encoded");
+	return channel;
+}
+function createReleaseCatalogScopeKey(input) {
+	decodeChannelKey(input.channelKey);
+	if (input.strategy === "APP_VERSION") return `v1:app-version:${input.platform}:${input.channelKey}`;
+	assertCatalogSegment(input.fingerprintHash, "Fingerprint hash");
+	return `v1:fingerprint:${input.platform}:${input.channelKey}:${input.fingerprintHash}`;
+}
+var UUID_V7_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var isUUIDv7 = (value) => typeof value === "string" && UUID_V7_PATTERN.test(value);
+//#endregion
+export { normalizeCohortValue as C, isValidCohort as S, stripBundleArtifactMetadata as T, getPatchStorageUri as _, createReleaseCatalogScopeKey as a, isReleaseEligibleForCohort as b, getAssetBaseStorageUri as c, getManifestStorageUri as d, getNumericCohortRolloutPosition as f, getPatchFileHash as g, getPatchBaseFileHash as h, RELEASE_CATALOG_FALLBACK_POLICY as i, getBundlePatches as l, getPatchBaseBundleId as m, MAX_COMPILED_CATALOG_BYTES as n, decodeChannelKey as o, getNumericCohortValue as p, NUMERIC_COHORT_SIZE as r, encodeChannelKey as s, INVALID_COHORT_ERROR_MESSAGE as t, getManifestFileHash as u, getRolledOutNumericCohorts as v, normalizeRolloutCohortCount as w, isUUIDv7 as x, isCustomCohort as y };

package/.output/server/_ssr/downloadBundle-CNnYxYO2.mjs

@@ -0,0 +1,24 @@
+//#region node_modules/.nitro/vite/services/ssr/assets/downloadBundle-CNnYxYO2.js
+var downloadBundle = async (bundleId, { databaseClient, storagePlugin }) => {
+	const bundle = await databaseClient.getBundleById(bundleId);
+	if (!bundle) return new Response("Bundle not found", { status: 404 });
+	const storageUri = bundle.storageUri;
+	if (!storageUri) return new Response("Bundle has no storage URI", { status: 404 });
+	const protocol = new URL(storageUri).protocol.replace(":", "");
+	if (storagePlugin?.protocol === protocol) {
+		const { response } = await storagePlugin.get({ storageUri });
+		if (!response) return new Response("Storage object not found", { status: 404 });
+		const headers = new Headers(response.headers);
+		headers.set("cache-control", "private, no-store");
+		headers.set("content-disposition", "attachment");
+		return new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	}
+	if (protocol !== "http" && protocol !== "https") return new Response(`No storage plugin for protocol: ${protocol}`, { status: 503 });
+	return Response.redirect(storageUri, 302);
+};
+//#endregion
+export { downloadBundle };

package/.output/server/_ssr/{empty-plugin-adapters-B4HCzgmM.mjs → empty-plugin-adapters-B5QvGpEl.mjs}

@@ -1,4 +1,4 @@
-//#region node_modules/.nitro/vite/services/ssr/assets/empty-plugin-adapters-B4HCzgmM.js
+//#region node_modules/.nitro/vite/services/ssr/assets/empty-plugin-adapters-B5QvGpEl.js
 var pluginSerializationAdapters = [];
 var hasPluginAdapters = false;
 //#endregion

package/.output/server/_ssr/field-DRIXKjZG.mjs

@@ -0,0 +1,74 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { at as require_react, it as require_jsx_runtime } 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/field-DRIXKjZG.js
+var import_react = /* @__PURE__ */ __toESM(require_react());
+var import_jsx_runtime = require_jsx_runtime();
+function Label({ className, htmlFor, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("label", {
+		"data-slot": "label",
+		htmlFor,
+		className: cn("flex items-center gap-2 text-xs/relaxed leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50", className),
+		...props
+	});
+}
+function FieldGroup({ className, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		"data-slot": "field-group",
+		className: cn("gap-4 data-[slot=checkbox-group]:gap-3 [&>[data-slot=field-group]]:gap-4 group/field-group @container/field-group flex w-full flex-col", className),
+		...props
+	});
+}
+var fieldVariants = cva("data-[invalid=true]:text-destructive gap-2 group/field flex w-full", {
+	variants: { orientation: {
+		vertical: "flex-col [&>*]:w-full [&>.sr-only]:w-auto",
+		horizontal: "flex-row items-center [&>[data-slot=field-label]]:flex-auto has-[>[data-slot=field-content]]:items-start has-[>[data-slot=field-content]]:[&>[role=checkbox],[role=radio]]:mt-px",
+		responsive: "flex-col [&>*]:w-full [&>.sr-only]:w-auto @md/field-group:flex-row @md/field-group:items-center @md/field-group:[&>*]:w-auto @md/field-group:[&>[data-slot=field-label]]:flex-auto @md/field-group:has-[>[data-slot=field-content]]:items-start @md/field-group:has-[>[data-slot=field-content]]:[&>[role=checkbox],[role=radio]]:mt-px"
+	} },
+	defaultVariants: { orientation: "vertical" }
+});
+function Field({ className, orientation = "vertical", ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		"data-slot": "field",
+		"data-orientation": orientation,
+		className: cn(fieldVariants({ orientation }), className),
+		...props
+	});
+}
+function FieldLabel({ className, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label, {
+		"data-slot": "field-label",
+		className: cn("has-data-checked:bg-primary/5 dark:has-data-checked:bg-primary/10 gap-2 group-data-[disabled=true]/field:opacity-50 has-[>[data-slot=field]]:rounded-md has-[>[data-slot=field]]:border [&>*]:data-[slot=field]:p-2 group/field-label peer/field-label flex w-fit leading-snug", "has-[>[data-slot=field]]:w-full has-[>[data-slot=field]]:flex-col", className),
+		...props
+	});
+}
+function FieldDescription({ className, ...props }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+		"data-slot": "field-description",
+		className: cn("text-muted-foreground text-left text-xs/relaxed [[data-variant=legend]+&]:-mt-1.5 leading-normal font-normal group-has-[[data-orientation=horizontal]]/field:text-balance", "last:mt-0 nth-last-2:-mt-1", "[&>a:hover]:text-primary [&>a]:underline [&>a]:underline-offset-4", className),
+		...props
+	});
+}
+function FieldError({ className, children, errors, ...props }) {
+	const content = (0, import_react.useMemo)(() => {
+		if (children) return children;
+		if (!errors?.length) return null;
+		const uniqueErrors = [...new Map(errors.map((error) => [error?.message, error])).values()];
+		if (uniqueErrors?.length === 1) return uniqueErrors[0]?.message;
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", {
+			className: "ml-4 flex list-disc flex-col gap-1",
+			children: uniqueErrors.map((error, index) => error?.message && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("li", { children: error.message }, index))
+		});
+	}, [children, errors]);
+	if (!content) return null;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		role: "alert",
+		"data-slot": "field-error",
+		className: cn("text-destructive text-xs/relaxed font-normal", className),
+		...props,
+		children: content
+	});
+}
+//#endregion
+export { FieldLabel as a, FieldGroup as i, FieldDescription as n, Label as o, FieldError as r, Field as t };

package/.output/server/_ssr/{getBundleChildren-CVtSiH5t.mjs → getBundleChildren-BcRMFoDF.mjs}

@@ -1,39 +1,31 @@
-import { i as getBundlePatches } from "./dist-KboydRVk.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/getBundleChildren-CVtSiH5t.js
+import { l as getBundlePatches } from "./dist-BVSLTpoP.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/getBundleChildren-BcRMFoDF.js
 var CHILDREN_QUERY_LIMIT = 100;
 async function collectBundleChildrenByBaseIds(baseBundleIds, deps) {
 	const uniqueBaseBundleIds = [...new Set(baseBundleIds.filter(Boolean))];
 	const bundlesByBaseId = Object.fromEntries(uniqueBaseBundleIds.map((bundleId) => [bundleId, []]));
-	const baseBundles = (await Promise.all(uniqueBaseBundleIds.map((bundleId) => deps.databasePlugin.getBundleById(bundleId)))).filter((bundle) => Boolean(bundle));
+	const baseBundles = (await Promise.all(uniqueBaseBundleIds.map((bundleId) => deps.databaseClient.getBundleById(bundleId)))).filter((bundle) => Boolean(bundle));
 	const groupMap = /* @__PURE__ */ new Map();
 	for (const baseBundle of baseBundles) {
-		const groupKey = `${baseBundle.channel}:${baseBundle.platform}`;
-		const existingGroup = groupMap.get(groupKey);
+		const existingGroup = groupMap.get(baseBundle.platform);
 		if (existingGroup) {
-			existingGroup.bundleIds.add(baseBundle.id);
+			existingGroup.add(baseBundle.id);
 			continue;
 		}
-		groupMap.set(groupKey, {
-			channel: baseBundle.channel,
-			platform: baseBundle.platform,
-			bundleIds: new Set([baseBundle.id])
-		});
+		groupMap.set(baseBundle.platform, new Set([baseBundle.id]));
 	}
-	for (const group of groupMap.values()) {
+	for (const [platform, bundleIds] of groupMap) {
 		const seenBundleIds = /* @__PURE__ */ new Set();
 		const seenCursors = /* @__PURE__ */ new Set();
 		let after;
 		while (true) {
-			const page = await deps.databasePlugin.getBundles({
-				where: {
-					channel: group.channel,
-					platform: group.platform
-				},
+			const page = await deps.databaseClient.getBundles({
+				where: { platform },
 				limit: CHILDREN_QUERY_LIMIT,
 				cursor: after ? { after } : void 0
 			});
 			for (const bundle of page.data) {
-				const matchedParentBundleIds = getBundlePatches(bundle).map((patch) => patch.baseBundleId).filter((bundleId) => group.bundleIds.has(bundleId));
+				const matchedParentBundleIds = getBundlePatches(bundle).map((patch) => patch.baseBundleId).filter((bundleId) => bundleIds.has(bundleId));
 				if (matchedParentBundleIds.length === 0 || seenBundleIds.has(bundle.id)) continue;
 				seenBundleIds.add(bundle.id);
 				for (const parentBundleId of matchedParentBundleIds) bundlesByBaseId[parentBundleId]?.push(bundle);

package/.output/server/_ssr/installations-B-azgAvX.mjs

@@ -0,0 +1,19 @@
+import { d as createFileRoute, u as lazyRouteComponent } from "../_libs/@tanstack/react-router+[...].mjs";
+import { t as ensureAnalyticsRouteAccess } from "./analytics-api-Cg1M5v_H.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/installations-B-azgAvX.js
+function validateInstallationsSearch(search) {
+	return {
+		query: typeof search.query === "string" ? search.query : void 0,
+		installId: typeof search.installId === "string" ? search.installId : void 0,
+		searchOffset: typeof search.searchOffset === "number" && Number.isSafeInteger(search.searchOffset) && search.searchOffset >= 0 ? search.searchOffset : 0,
+		historyOffset: typeof search.historyOffset === "number" && Number.isSafeInteger(search.historyOffset) && search.historyOffset >= 0 ? search.historyOffset : 0
+	};
+}
+var $$splitComponentImporter = () => import("./installations-Ctvzp2JH.mjs");
+var Route = createFileRoute("/installations")({
+	beforeLoad: ({ context }) => ensureAnalyticsRouteAccess(context.queryClient),
+	component: lazyRouteComponent($$splitComponentImporter, "component"),
+	validateSearch: validateInstallationsSearch
+});
+//#endregion
+export { Route as t };