@hot-updater/standalone 0.36.7 → 1.0.0-rc.1

package/dist/index.mjs

@@ -1,46 +1,331 @@
-import { createDatabasePlugin } from "@hot-updater/plugin-core";
-import fs from "fs/promises";
-import path from "path";
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+import { bundleToPatchRows, bundleToRow, createStoragePlugin, parseStorageUri } from "@hot-updater/plugin-core";
+//#region src/standaloneBundleRows.ts
+async function loadRows(remote, model) {
+	return model === "bundles" ? remote.loadBundleRows() : (await remote.loadBundles()).flatMap(bundleToPatchRows);
+}
+//#endregion
+//#region src/standaloneDatabaseQuery.ts
+const compare$1 = (left, right) => {
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	return String(left).localeCompare(String(right));
+};
+const compareString = (actual, expected, mode, predicate) => {
+	if (typeof actual !== "string") return false;
+	return mode === "insensitive" ? predicate(actual.toLocaleLowerCase(), expected.toLocaleLowerCase()) : predicate(actual, expected);
+};
+const matchesCondition = (row, condition) => {
+	const actual = Reflect.get(row, condition.field);
+	const expected = Reflect.get(condition, "value");
+	switch (Reflect.get(condition, "operator") ?? "eq") {
+		case "eq":
+			if (typeof expected === "string") return compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value === query);
+			return actual === expected;
+		case "ne":
+			if (actual === null || actual === void 0) return false;
+			if (typeof expected === "string") return !compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value === query);
+			return actual !== expected;
+		case "gt":
+			if (actual === null || actual === void 0) return false;
+			return compare$1(actual, expected) > 0;
+		case "gte":
+			if (actual === null || actual === void 0) return false;
+			return compare$1(actual, expected) >= 0;
+		case "lt":
+			if (actual === null || actual === void 0) return false;
+			return compare$1(actual, expected) < 0;
+		case "lte":
+			if (actual === null || actual === void 0) return false;
+			return compare$1(actual, expected) <= 0;
+		case "in": return Array.isArray(expected) && expected.some((candidate) => candidate === actual);
+		case "not_in": return Array.isArray(expected) && (expected.length === 0 || actual !== null && actual !== void 0 && expected.every((candidate) => candidate !== actual));
+		case "contains": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.includes(query)) : false;
+		case "starts_with": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.startsWith(query)) : false;
+		case "ends_with": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.endsWith(query)) : false;
+		default: return false;
+	}
+};
+const matchesStandaloneWhere = (row, where) => {
+	if (!where || where.length === 0) return true;
+	let result = matchesCondition(row, where[0]);
+	for (const condition of where.slice(1)) {
+		const current = matchesCondition(row, condition);
+		result = condition.connector === "OR" ? result || current : result && current;
+	}
+	return result;
+};
+const queryStandaloneRows = (rows, input) => {
+	const filtered = rows.filter((row) => matchesStandaloneWhere(row, input.where));
+	if (input.orderBy) {
+		const direction = input.orderBy.direction === "asc" ? 1 : -1;
+		filtered.sort((left, right) => compare$1(Reflect.get(left, input.orderBy?.field ?? "id"), Reflect.get(right, input.orderBy?.field ?? "id")) * direction);
+	}
+	const offset = input.offset ?? 0;
+	return filtered.slice(offset, offset + (input.limit ?? filtered.length));
+};
+//#endregion
+//#region src/standaloneBundleReads.ts
+const compare = (left, right) => {
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	return String(left).localeCompare(String(right));
+};
+const queryBundleRows = (rows, input) => {
+	const filtered = queryStandaloneRows(rows, { where: input.where });
+	const orderBy = input.orderBy;
+	if (orderBy !== void 0) filtered.sort((left, right) => {
+		for (const clause of orderBy) {
+			const leftValue = Reflect.get(left, clause.field);
+			const rightValue = Reflect.get(right, clause.field);
+			if (leftValue === rightValue) continue;
+			if (leftValue === null || rightValue === null) {
+				const nulls = clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
+				return leftValue === null ? nulls === "first" ? -1 : 1 : nulls === "first" ? 1 : -1;
+			}
+			const result = compare(leftValue, rightValue);
+			if (result !== 0) return clause.direction === "asc" ? result : -result;
+		}
+		return 0;
+	});
+	return (input.distinctOn === void 0 ? filtered : filtered.filter((row, index, ordered) => ordered.findIndex((candidate) => JSON.stringify(input.distinctOn?.fields.map((field) => Reflect.get(candidate, field))) === JSON.stringify(input.distinctOn?.fields.map((field) => Reflect.get(row, field)))) === index)).slice(input.offset, input.offset + input.limit);
+};
+const countDistinctRows = (rows, fields) => fields === void 0 ? rows.length : new Set(rows.map((row) => JSON.stringify(fields.map((field) => Reflect.get(row, field))))).size;
+const createBundleReads = (remote) => ({
+	async count(input) {
+		switch (input.model) {
+			case "bundles": {
+				const where = input.where;
+				if (input.distinct === void 0) {
+					const remoteWindow = await remote.loadBundleWindow({
+						where,
+						limit: 1,
+						offset: 0
+					});
+					if (remoteWindow) return remoteWindow.total;
+				}
+				return countDistinctRows(queryStandaloneRows(await loadRows(remote, "bundles"), { where }), input.distinct);
+			}
+			case "bundle_patches": return countDistinctRows(queryStandaloneRows(await loadRows(remote, "bundle_patches"), { where: input.where }), input.distinct);
+		}
+	},
+	async findOne(input) {
+		if (input.model === "bundles") {
+			const idSelector = input.where?.length === 1 ? input.where[0] : void 0;
+			if (idSelector?.field === "id" && (idSelector.operator === void 0 || idSelector.operator === "eq") && typeof idSelector.value === "string") {
+				const row = await remote.loadBundleRow(idSelector.value);
+				return row && matchesStandaloneWhere(row, input.where) ? row : null;
+			}
+			return queryStandaloneRows(await loadRows(remote, "bundles"), {
+				where: input.where,
+				limit: 1
+			})[0] ?? null;
+		}
+		return queryStandaloneRows(await loadRows(remote, "bundle_patches"), {
+			where: input.where,
+			limit: 1
+		})[0] ?? null;
+	},
+	async findMany(input) {
+		switch (input.model) {
+			case "bundles": {
+				const where = input.where;
+				const orderBy = input.orderBy;
+				const remoteSort = orderBy?.length === 1 && orderBy[0]?.field === "id" ? orderBy[0] : void 0;
+				if (input.distinctOn === void 0 && (orderBy === void 0 || remoteSort)) {
+					const remoteWindow = await remote.loadBundleWindow({
+						where,
+						limit: input.limit,
+						offset: input.offset,
+						orderBy: remoteSort
+					});
+					if (remoteWindow) return remoteWindow.rows;
+				}
+				return queryBundleRows(await loadRows(remote, "bundles"), {
+					distinctOn: input.distinctOn,
+					where,
+					limit: input.limit,
+					offset: input.offset,
+					orderBy: input.orderBy
+				});
+			}
+			case "bundle_patches": return queryBundleRows(await loadRows(remote, "bundle_patches"), {
+				distinctOn: input.distinctOn,
+				where: input.where,
+				limit: input.limit,
+				offset: input.offset,
+				orderBy: input.orderBy
+			});
+		}
+	}
+});
+//#endregion
+//#region src/standaloneBundleReader.ts
+const createStandaloneBundleReader = (remote) => createBundleReads(remote);
+//#endregion
+//#region src/standaloneBundleWhere.ts
+const appendBundleWhere = (url, where) => {
+	const usedParameters = /* @__PURE__ */ new Set();
+	const setParameter = (parameter, value) => {
+		if (usedParameters.has(parameter)) return false;
+		usedParameters.add(parameter);
+		url.searchParams.set(parameter, value);
+		return true;
+	};
+	const appendParameter = (parameter, values) => {
+		if (values.length === 0 || usedParameters.has(parameter)) return false;
+		usedParameters.add(parameter);
+		for (const value of values) url.searchParams.append(parameter, value);
+		return true;
+	};
+	for (const [index, condition] of (where ?? []).entries()) {
+		if (index > 0 && condition.connector === "OR") return false;
+		const operator = condition.operator ?? "eq";
+		switch (condition.field) {
+			case "platform":
+				if (operator !== "eq" || typeof condition.value !== "string") return false;
+				if (!setParameter("platform", condition.value)) return false;
+				break;
+			case "id": {
+				let parameter;
+				switch (operator) {
+					case "eq":
+						parameter = "idEq";
+						break;
+					case "gt":
+						parameter = "idGt";
+						break;
+					case "gte":
+						parameter = "idGte";
+						break;
+					case "lt":
+						parameter = "idLt";
+						break;
+					case "lte":
+						parameter = "idLte";
+						break;
+				}
+				if (parameter && typeof condition.value === "string") {
+					if (!setParameter(parameter, condition.value)) return false;
+					break;
+				}
+				if (operator === "in" && Array.isArray(condition.value)) {
+					if (!condition.value.every((value) => typeof value === "string")) return false;
+					if (!appendParameter("idIn", condition.value)) return false;
+					break;
+				}
+				return false;
+			}
+			default: return false;
+		}
+	}
+	return true;
+};
+//#endregion
+//#region src/standaloneHttp.ts
+var StandaloneDatabaseError = class extends Error {
+	name = "StandaloneDatabaseError";
+	constructor(code, message, status) {
+		super(message);
+		this.code = code;
+		this.status = status;
+	}
+};
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const createStandaloneHttp = (config) => {
+	const baseUrl = config.baseUrl.replace(/\/+$/, "");
+	const buildUrl = (path) => `${baseUrl}${path}`;
+	const headers = (routeHeaders) => ({
+		"Content-Type": "application/json",
+		...config.commonHeaders,
+		...routeHeaders
+	});
+	const requestFailed = async (response) => {
+		let message = `Database request failed with status ${response.status}.`;
+		try {
+			const body = await response.json();
+			if (isRecord$2(body) && typeof body.message === "string") message = body.message;
+			else if (isRecord$2(body) && typeof body.error === "string") message = body.error;
+		} catch (error) {
+			if (!(error instanceof SyntaxError)) throw error;
+		}
+		throw new StandaloneDatabaseError("request-failed", message, response.status);
+	};
+	const parseJson = async (response) => {
+		if (!response.ok) return requestFailed(response);
+		try {
+			return await response.json();
+		} catch {
+			throw new StandaloneDatabaseError("invalid-response", "Database response must contain JSON.", response.status);
+		}
+	};
+	const load = async (route, searchParams, isResult, invalidMessage, signal) => {
+		const url = new URL(buildUrl(route.path));
+		for (const [key, value] of Object.entries(searchParams)) url.searchParams.set(key, value);
+		const response = await fetch(url, {
+			method: "GET",
+			headers: headers(route.headers),
+			signal
 		});
+		const value = await parseJson(response);
+		if (!isResult(value)) throw new StandaloneDatabaseError("invalid-response", invalidMessage, response.status);
+		return value;
+	};
+	return {
+		buildUrl,
+		headers,
+		load,
+		parseJson,
+		requestFailed
+	};
+};
+//#endregion
+//#region src/standaloneResponseGuards.ts
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isNonNegativeInteger = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+const isByteSize = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const isBundlePatch = (value) => isRecord$1(value) && typeof value.baseBundleId === "string" && typeof value.baseFileHash === "string" && isByteSize(value.byteSize) && typeof value.patchFileHash === "string" && typeof value.patchStorageUri === "string";
+const isChannelText = (value) => {
+	if (typeof value !== "string" || value.length === 0) return false;
+	let codePoints = 0;
+	for (const _codePoint of value) {
+		codePoints += 1;
+		if (codePoints > 255) return false;
 	}
-	return to;
+	return true;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+const isChannelRow = (value) => isRecord$1(value) && isChannelText(value.id) && isChannelText(value.name);
+const isBundle = (value) => isRecord$1(value) && typeof value.id === "string" && (value.platform === "ios" || value.platform === "android") && typeof value.fileHash === "string" && typeof value.storageUri === "string" && isByteSize(value.archiveByteSize) && (value.patches === void 0 || value.patches === null || Array.isArray(value.patches) && value.patches.every(isBundlePatch));
+const isPaginationInfo = (value) => isRecord$1(value) && isNonNegativeInteger(value.total) && typeof value.hasNextPage === "boolean" && typeof value.hasPreviousPage === "boolean" && isNonNegativeInteger(value.currentPage) && value.currentPage >= 1 && isNonNegativeInteger(value.totalPages);
+const isPaginatedResult = (value) => isRecord$1(value) && Array.isArray(value.data) && value.data.every(isBundle) && isPaginationInfo(value.pagination);
+const hasChannels = (value) => isRecord$1(value) && isRecord$1(value.data) && Array.isArray(value.data.channels) && value.data.channels.every(isChannelRow);
+const hasChannelInsertResult = (value) => isRecord$1(value) && isRecord$1(value.data) && isChannelRow(value.data.row) && typeof value.data.inserted === "boolean";
+const hasChannelDeleteResult = (value) => isRecord$1(value) && isRecord$1(value.data) && (value.data.deleted === true || value.data.deleted === false && (value.data.reason === "not_empty" || value.data.reason === "not_found"));
 //#endregion
-//#region src/standaloneRepository.ts
+//#region src/standaloneRoutes.ts
+function bundlePath(bundleId) {
+	return `/bundles/${encodeURIComponent(bundleId)}`;
+}
+function channelPath(channelId) {
+	return `/channels/${encodeURIComponent(channelId)}`;
+}
 const defaultRoutes$1 = {
-	create: () => ({ path: "/api/bundles" }),
-	update: (bundleId) => ({ path: `/api/bundles/${bundleId}` }),
+	create: () => ({ path: "/bundles" }),
+	update: (bundleId) => ({ path: bundlePath(bundleId) }),
 	list: () => ({
-		path: "/api/bundles",
+		path: "/bundles",
 		headers: { "Cache-Control": "no-cache" }
 	}),
 	channels: () => ({
-		path: "/api/bundles/channels",
+		path: "/channels",
 		headers: { "Cache-Control": "no-cache" }
 	}),
+	deleteChannel: (channelId) => ({
+		path: channelPath(channelId),
+		headers: {}
+	}),
 	retrieve: (bundleId) => ({
-		path: `/api/bundles/${bundleId}`,
+		path: bundlePath(bundleId),
 		headers: { Accept: "application/json" }
 	}),
-	delete: (bundleId) => ({ path: `/api/bundles/${bundleId}` })
+	delete: (bundleId) => ({ path: bundlePath(bundleId) })
 };
 const createRoute$1 = (defaultRoute, customRoute) => ({
 	path: customRoute?.path ?? defaultRoute.path,
@@ -49,1453 +334,339 @@ const createRoute$1 = (defaultRoute, customRoute) => ({
 		...customRoute?.headers
 	}
 });
-const appendPathSegment = (path, segment) => `${path.replace(/\/+$/, "")}/${segment}`;
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
-const isPaginatedResult = (value) => isRecord(value) && Array.isArray(value.data) && isRecord(value.pagination);
-const hasDataChannels = (value) => isRecord(value) && isRecord(value.data) && isStringArray(value.data.channels);
-const setBooleanSearchParam = (url, key, value) => {
-	if (value !== void 0) url.searchParams.set(key, String(value));
-};
-const setNullableStringSearchParam = (url, key, value) => {
-	if (value !== void 0) url.searchParams.set(key, value === null ? "null" : value);
-};
-const appendStringArraySearchParams = (url, key, values) => {
-	for (const value of values ?? []) url.searchParams.append(key, value);
-};
-const setBundleIdFilterSearchParams = (url, filter) => {
-	if (!filter) return;
-	if (filter.eq !== void 0) url.searchParams.set("idEq", filter.eq);
-	if (filter.gt !== void 0) url.searchParams.set("idGt", filter.gt);
-	if (filter.gte !== void 0) url.searchParams.set("idGte", filter.gte);
-	if (filter.lt !== void 0) url.searchParams.set("idLt", filter.lt);
-	if (filter.lte !== void 0) url.searchParams.set("idLte", filter.lte);
-	appendStringArraySearchParams(url, "idIn", filter.in);
-};
-const standaloneRepository = createDatabasePlugin({
-	name: "standalone-repository",
-	factory: (config) => {
-		const customListRoute = config.routes?.list?.();
-		const routes = {
-			list: () => createRoute$1(defaultRoutes$1.list(), customListRoute),
-			channels: () => {
-				return createRoute$1(customListRoute ? {
-					path: appendPathSegment(customListRoute.path, "channels"),
-					headers: {
-						...defaultRoutes$1.channels().headers,
-						...customListRoute.headers
-					}
-				} : defaultRoutes$1.channels(), config.routes?.channels?.());
-			},
-			create: () => createRoute$1(defaultRoutes$1.create(), config.routes?.create?.()),
-			update: (bundleId) => createRoute$1(defaultRoutes$1.update(bundleId), config.routes?.update?.(bundleId)),
-			retrieve: (bundleId) => createRoute$1(defaultRoutes$1.retrieve(bundleId), config.routes?.retrieve?.(bundleId)),
-			delete: (bundleId) => createRoute$1(defaultRoutes$1.delete(bundleId), config.routes?.delete?.(bundleId))
+//#endregion
+//#region src/standaloneBundleRemote.ts
+const PAGE_SIZE = 100;
+const createStandaloneBundleRemote = (config) => {
+	const routes = {
+		list: () => createRoute$1(defaultRoutes$1.list(), config.routes?.list?.()),
+		channels: defaultRoutes$1.channels,
+		deleteChannel: defaultRoutes$1.deleteChannel,
+		create: () => createRoute$1(defaultRoutes$1.create(), config.routes?.create?.()),
+		update: (bundleId) => createRoute$1(defaultRoutes$1.update(bundleId), config.routes?.update?.(bundleId)),
+		retrieve: (bundleId) => createRoute$1(defaultRoutes$1.retrieve(bundleId), config.routes?.retrieve?.(bundleId)),
+		delete: (bundleId) => createRoute$1(defaultRoutes$1.delete(bundleId), config.routes?.delete?.(bundleId))
+	};
+	const http = createStandaloneHttp(config);
+	const loadBundles = async () => {
+		const bundles = [];
+		for (let page = 1;; page += 1) {
+			const route = routes.list();
+			const url = new URL(http.buildUrl(route.path));
+			url.searchParams.set("limit", String(PAGE_SIZE));
+			url.searchParams.set("page", String(page));
+			const response = await fetch(url, {
+				method: "GET",
+				headers: http.headers(route.headers)
+			});
+			const value = await http.parseJson(response);
+			if (!isPaginatedResult(value)) throw new StandaloneDatabaseError("invalid-response", "Invalid bundle list response.", response.status);
+			bundles.push(...value.data);
+			if (value.data.length < PAGE_SIZE || value.pagination.hasNextPage === false || bundles.length >= value.pagination.total) return bundles;
+		}
+	};
+	const loadChannels = async () => {
+		const route = routes.channels();
+		const response = await fetch(http.buildUrl(route.path), {
+			method: "GET",
+			headers: http.headers(route.headers)
+		});
+		const value = await http.parseJson(response);
+		if (!hasChannels(value)) throw new StandaloneDatabaseError("invalid-response", "Invalid channels response.", response.status);
+		return value.data.channels;
+	};
+	const bundlesToRows = async (bundles) => bundles.map((bundle) => bundleToRow(bundle));
+	const loadBundleWindow = async (input) => {
+		if (input.limit === 0) return {
+			rows: [],
+			total: 0
 		};
-		const buildUrl = (path) => `${config.baseUrl}${path}`;
-		const getHeaders = (routeHeaders) => ({
-			"Content-Type": "application/json",
-			...config.commonHeaders,
-			...routeHeaders
+		if (input.orderBy && input.orderBy.field !== "id") return null;
+		const route = routes.list();
+		const url = new URL(http.buildUrl(route.path));
+		if (!appendBundleWhere(url, input.where)) return null;
+		if (input.orderBy !== void 0) url.searchParams.set("orderDirection", input.orderBy.direction);
+		const pageAligned = input.limit > 0 && input.offset % input.limit === 0;
+		const remoteLimit = pageAligned ? input.limit : input.offset + input.limit;
+		if (remoteLimit > PAGE_SIZE) return null;
+		url.searchParams.set("limit", String(remoteLimit));
+		url.searchParams.set("page", String(pageAligned ? input.offset / input.limit + 1 : 1));
+		const response = await fetch(url, {
+			method: "GET",
+			headers: http.headers(route.headers)
 		});
+		const value = await http.parseJson(response);
+		if (!isPaginatedResult(value)) throw new StandaloneDatabaseError("invalid-response", "Invalid bundle list response.", response.status);
 		return {
-			supportsCursorPagination: true,
-			async getBundleById(bundleId) {
-				try {
-					const { path, headers: routeHeaders } = routes.retrieve(bundleId);
-					const response = await fetch(buildUrl(path), {
-						method: "GET",
-						headers: getHeaders(routeHeaders)
-					});
-					if (!response.ok) return null;
-					return await response.json();
-				} catch {
-					return null;
-				}
-			},
-			async getBundles(options) {
-				const { where, limit, cursor, page } = options ?? {};
-				const internalOffset = options && typeof options === "object" && "offset" in options && typeof options.offset === "number" ? options.offset : void 0;
-				const { path, headers: routeHeaders } = routes.list();
-				const url = new URL(buildUrl(path));
-				const resolvedPage = page ?? (internalOffset !== void 0 && limit > 0 ? Math.floor(internalOffset / limit) + 1 : void 0);
-				if (where?.channel !== void 0) url.searchParams.set("channel", where.channel);
-				if (where?.platform !== void 0) url.searchParams.set("platform", where.platform);
-				setBooleanSearchParam(url, "enabled", where?.enabled);
-				setBundleIdFilterSearchParams(url, where?.id);
-				setNullableStringSearchParam(url, "targetAppVersion", where?.targetAppVersion);
-				appendStringArraySearchParams(url, "targetAppVersionIn", where?.targetAppVersionIn);
-				setBooleanSearchParam(url, "targetAppVersionNotNull", where?.targetAppVersionNotNull);
-				setNullableStringSearchParam(url, "fingerprintHash", where?.fingerprintHash);
-				if (limit !== void 0) url.searchParams.set("limit", String(limit));
-				if (resolvedPage !== void 0) url.searchParams.set("page", String(resolvedPage));
-				if (cursor?.after !== void 0) url.searchParams.set("after", cursor.after);
-				if (cursor?.before !== void 0) url.searchParams.set("before", cursor.before);
-				const response = await fetch(url.toString(), {
-					method: "GET",
-					headers: getHeaders(routeHeaders)
-				});
-				if (!response.ok) throw new Error(`API Error: ${response.statusText}`);
-				const result = await response.json();
-				if (isPaginatedResult(result)) return result;
-				throw new Error("API Error: Invalid bundle list response");
-			},
-			async getChannels() {
-				const { path, headers: routeHeaders } = routes.channels();
-				const response = await fetch(buildUrl(path), {
-					method: "GET",
-					headers: getHeaders(routeHeaders)
-				});
-				if (!response.ok) throw new Error(`API Error: ${response.statusText}`);
-				const result = await response.json();
-				if (hasDataChannels(result)) return result.data.channels;
-				throw new Error("API Error: Invalid channels response");
-			},
-			async commitBundle({ changedSets }) {
-				if (changedSets.length === 0) return;
-				for (const op of changedSets) if (op.operation === "delete") {
-					const { path, headers: routeHeaders } = routes.delete(op.data.id);
-					const response = await fetch(buildUrl(path), {
-						method: "DELETE",
-						headers: getHeaders(routeHeaders)
-					});
-					if (!response.ok) {
-						if (response.status === 404) throw new Error(`Bundle with id ${op.data.id} not found`);
-						throw new Error(`API Error: ${response.status} ${response.statusText}`);
-					}
-					if (response.headers.get("content-type")?.includes("application/json")) try {
-						await response.json();
-					} catch {
-						if (!response.ok) throw new Error("Failed to parse response");
-					}
-				} else if (op.operation === "insert") {
-					const { path, headers: routeHeaders } = routes.create();
-					const response = await fetch(buildUrl(path), {
-						method: "POST",
-						headers: getHeaders(routeHeaders),
-						body: JSON.stringify([op.data])
-					});
-					if (!response.ok) throw new Error(`API Error: ${response.statusText}`);
-					if (!(await response.json()).success) throw new Error("Failed to commit bundle");
-				} else if (op.operation === "update") {
-					const { path, headers: routeHeaders } = routes.update(op.data.id);
-					const response = await fetch(buildUrl(path), {
-						method: "PATCH",
-						headers: getHeaders(routeHeaders),
-						body: JSON.stringify(op.data)
-					});
-					if (!response.ok) throw new Error(`API Error: ${response.statusText}`);
-					if (!(await response.json()).success) throw new Error("Failed to commit bundle");
-				}
-			}
+			rows: await bundlesToRows(pageAligned ? value.data : value.data.slice(input.offset, input.offset + input.limit)),
+			total: value.pagination.total
 		};
-	}
-});
-//#endregion
-//#region ../../node_modules/.pnpm/mime@2.6.0/node_modules/mime/Mime.js
-var require_Mime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	/**
-	* @param typeMap [Object] Map of MIME type -> Array[extensions]
-	* @param ...
-	*/
-	function Mime() {
-		this._types = Object.create(null);
-		this._extensions = Object.create(null);
-		for (let i = 0; i < arguments.length; i++) this.define(arguments[i]);
-		this.define = this.define.bind(this);
-		this.getType = this.getType.bind(this);
-		this.getExtension = this.getExtension.bind(this);
-	}
-	/**
-	* Define mimetype -> extension mappings.  Each key is a mime-type that maps
-	* to an array of extensions associated with the type.  The first extension is
-	* used as the default extension for the type.
-	*
-	* e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});
-	*
-	* If a type declares an extension that has already been defined, an error will
-	* be thrown.  To suppress this error and force the extension to be associated
-	* with the new type, pass `force`=true.  Alternatively, you may prefix the
-	* extension with "*" to map the type to extension, without mapping the
-	* extension to the type.
-	*
-	* e.g. mime.define({'audio/wav', ['wav']}, {'audio/x-wav', ['*wav']});
-	*
-	*
-	* @param map (Object) type definitions
-	* @param force (Boolean) if true, force overriding of existing definitions
-	*/
-	Mime.prototype.define = function(typeMap, force) {
-		for (let type in typeMap) {
-			let extensions = typeMap[type].map(function(t) {
-				return t.toLowerCase();
-			});
-			type = type.toLowerCase();
-			for (let i = 0; i < extensions.length; i++) {
-				const ext = extensions[i];
-				if (ext[0] === "*") continue;
-				if (!force && ext in this._types) throw new Error("Attempt to change mapping for \"" + ext + "\" extension from \"" + this._types[ext] + "\" to \"" + type + "\". Pass `force=true` to allow this, otherwise remove \"" + ext + "\" from the list of extensions for \"" + type + "\".");
-				this._types[ext] = type;
-			}
-			if (force || !this._extensions[type]) {
-				const ext = extensions[0];
-				this._extensions[type] = ext[0] !== "*" ? ext : ext.substr(1);
-			}
+	};
+	const insertChannel = async (input) => {
+		const route = routes.channels();
+		const response = await fetch(http.buildUrl(route.path), {
+			method: "POST",
+			headers: http.headers(route.headers),
+			body: JSON.stringify(input)
+		});
+		const value = await http.parseJson(response);
+		if (!hasChannelInsertResult(value)) throw new StandaloneDatabaseError("invalid-response", "Invalid Channel insert response.", response.status);
+		if (value.data.row.name !== input.row.name || value.data.inserted && value.data.row.id !== input.row.id) throw new StandaloneDatabaseError("invalid-response", "Invalid Channel insert response.", response.status);
+		return value.data;
+	};
+	const deleteChannel = async (input) => {
+		const route = routes.deleteChannel(input.id);
+		const response = await fetch(http.buildUrl(route.path), {
+			method: "DELETE",
+			headers: http.headers(route.headers)
+		});
+		if (response.status === 204) return { deleted: true };
+		let value;
+		try {
+			value = await response.json();
+		} catch {
+			throw new StandaloneDatabaseError("invalid-response", "Database response must contain JSON.", response.status);
 		}
+		if (!hasChannelDeleteResult(value)) throw new StandaloneDatabaseError("invalid-response", "Invalid Channel delete response.", response.status);
+		return value.data;
 	};
-	/**
-	* Lookup a mime type based on extension
-	*/
-	Mime.prototype.getType = function(path) {
-		path = String(path);
-		let last = path.replace(/^.*[/\\]/, "").toLowerCase();
-		let ext = last.replace(/^.*\./, "").toLowerCase();
-		let hasPath = last.length < path.length;
-		return (ext.length < last.length - 1 || !hasPath) && this._types[ext] || null;
+	const loadBundle = async (bundleId) => {
+		const route = routes.retrieve(bundleId);
+		const response = await fetch(http.buildUrl(route.path), {
+			method: "GET",
+			headers: http.headers(route.headers)
+		});
+		if (response.status === 404) return null;
+		const value = await http.parseJson(response);
+		if (!isBundle(value)) throw new StandaloneDatabaseError("invalid-response", "Invalid bundle response.", response.status);
+		return value;
 	};
-	/**
-	* Return file extension associated with a mime type
-	*/
-	Mime.prototype.getExtension = function(type) {
-		type = /^\s*([^;\s]*)/.test(type) && RegExp.$1;
-		return type && this._extensions[type.toLowerCase()] || null;
+	const loadBundleRow = async (bundleId) => {
+		const bundle = await loadBundle(bundleId);
+		return bundle ? (await bundlesToRows([bundle]))[0] ?? null : null;
 	};
-	module.exports = Mime;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/mime@2.6.0/node_modules/mime/types/standard.js
-var require_standard = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = {
-		"application/andrew-inset": ["ez"],
-		"application/applixware": ["aw"],
-		"application/atom+xml": ["atom"],
-		"application/atomcat+xml": ["atomcat"],
-		"application/atomdeleted+xml": ["atomdeleted"],
-		"application/atomsvc+xml": ["atomsvc"],
-		"application/atsc-dwd+xml": ["dwd"],
-		"application/atsc-held+xml": ["held"],
-		"application/atsc-rsat+xml": ["rsat"],
-		"application/bdoc": ["bdoc"],
-		"application/calendar+xml": ["xcs"],
-		"application/ccxml+xml": ["ccxml"],
-		"application/cdfx+xml": ["cdfx"],
-		"application/cdmi-capability": ["cdmia"],
-		"application/cdmi-container": ["cdmic"],
-		"application/cdmi-domain": ["cdmid"],
-		"application/cdmi-object": ["cdmio"],
-		"application/cdmi-queue": ["cdmiq"],
-		"application/cu-seeme": ["cu"],
-		"application/dash+xml": ["mpd"],
-		"application/davmount+xml": ["davmount"],
-		"application/docbook+xml": ["dbk"],
-		"application/dssc+der": ["dssc"],
-		"application/dssc+xml": ["xdssc"],
-		"application/ecmascript": ["es", "ecma"],
-		"application/emma+xml": ["emma"],
-		"application/emotionml+xml": ["emotionml"],
-		"application/epub+zip": ["epub"],
-		"application/exi": ["exi"],
-		"application/express": ["exp"],
-		"application/fdt+xml": ["fdt"],
-		"application/font-tdpfr": ["pfr"],
-		"application/geo+json": ["geojson"],
-		"application/gml+xml": ["gml"],
-		"application/gpx+xml": ["gpx"],
-		"application/gxf": ["gxf"],
-		"application/gzip": ["gz"],
-		"application/hjson": ["hjson"],
-		"application/hyperstudio": ["stk"],
-		"application/inkml+xml": ["ink", "inkml"],
-		"application/ipfix": ["ipfix"],
-		"application/its+xml": ["its"],
-		"application/java-archive": [
-			"jar",
-			"war",
-			"ear"
-		],
-		"application/java-serialized-object": ["ser"],
-		"application/java-vm": ["class"],
-		"application/javascript": ["js", "mjs"],
-		"application/json": ["json", "map"],
-		"application/json5": ["json5"],
-		"application/jsonml+json": ["jsonml"],
-		"application/ld+json": ["jsonld"],
-		"application/lgr+xml": ["lgr"],
-		"application/lost+xml": ["lostxml"],
-		"application/mac-binhex40": ["hqx"],
-		"application/mac-compactpro": ["cpt"],
-		"application/mads+xml": ["mads"],
-		"application/manifest+json": ["webmanifest"],
-		"application/marc": ["mrc"],
-		"application/marcxml+xml": ["mrcx"],
-		"application/mathematica": [
-			"ma",
-			"nb",
-			"mb"
-		],
-		"application/mathml+xml": ["mathml"],
-		"application/mbox": ["mbox"],
-		"application/mediaservercontrol+xml": ["mscml"],
-		"application/metalink+xml": ["metalink"],
-		"application/metalink4+xml": ["meta4"],
-		"application/mets+xml": ["mets"],
-		"application/mmt-aei+xml": ["maei"],
-		"application/mmt-usd+xml": ["musd"],
-		"application/mods+xml": ["mods"],
-		"application/mp21": ["m21", "mp21"],
-		"application/mp4": ["mp4s", "m4p"],
-		"application/msword": ["doc", "dot"],
-		"application/mxf": ["mxf"],
-		"application/n-quads": ["nq"],
-		"application/n-triples": ["nt"],
-		"application/node": ["cjs"],
-		"application/octet-stream": [
-			"bin",
-			"dms",
-			"lrf",
-			"mar",
-			"so",
-			"dist",
-			"distz",
-			"pkg",
-			"bpk",
-			"dump",
-			"elc",
-			"deploy",
-			"exe",
-			"dll",
-			"deb",
-			"dmg",
-			"iso",
-			"img",
-			"msi",
-			"msp",
-			"msm",
-			"buffer"
-		],
-		"application/oda": ["oda"],
-		"application/oebps-package+xml": ["opf"],
-		"application/ogg": ["ogx"],
-		"application/omdoc+xml": ["omdoc"],
-		"application/onenote": [
-			"onetoc",
-			"onetoc2",
-			"onetmp",
-			"onepkg"
-		],
-		"application/oxps": ["oxps"],
-		"application/p2p-overlay+xml": ["relo"],
-		"application/patch-ops-error+xml": ["xer"],
-		"application/pdf": ["pdf"],
-		"application/pgp-encrypted": ["pgp"],
-		"application/pgp-signature": ["asc", "sig"],
-		"application/pics-rules": ["prf"],
-		"application/pkcs10": ["p10"],
-		"application/pkcs7-mime": ["p7m", "p7c"],
-		"application/pkcs7-signature": ["p7s"],
-		"application/pkcs8": ["p8"],
-		"application/pkix-attr-cert": ["ac"],
-		"application/pkix-cert": ["cer"],
-		"application/pkix-crl": ["crl"],
-		"application/pkix-pkipath": ["pkipath"],
-		"application/pkixcmp": ["pki"],
-		"application/pls+xml": ["pls"],
-		"application/postscript": [
-			"ai",
-			"eps",
-			"ps"
-		],
-		"application/provenance+xml": ["provx"],
-		"application/pskc+xml": ["pskcxml"],
-		"application/raml+yaml": ["raml"],
-		"application/rdf+xml": ["rdf", "owl"],
-		"application/reginfo+xml": ["rif"],
-		"application/relax-ng-compact-syntax": ["rnc"],
-		"application/resource-lists+xml": ["rl"],
-		"application/resource-lists-diff+xml": ["rld"],
-		"application/rls-services+xml": ["rs"],
-		"application/route-apd+xml": ["rapd"],
-		"application/route-s-tsid+xml": ["sls"],
-		"application/route-usd+xml": ["rusd"],
-		"application/rpki-ghostbusters": ["gbr"],
-		"application/rpki-manifest": ["mft"],
-		"application/rpki-roa": ["roa"],
-		"application/rsd+xml": ["rsd"],
-		"application/rss+xml": ["rss"],
-		"application/rtf": ["rtf"],
-		"application/sbml+xml": ["sbml"],
-		"application/scvp-cv-request": ["scq"],
-		"application/scvp-cv-response": ["scs"],
-		"application/scvp-vp-request": ["spq"],
-		"application/scvp-vp-response": ["spp"],
-		"application/sdp": ["sdp"],
-		"application/senml+xml": ["senmlx"],
-		"application/sensml+xml": ["sensmlx"],
-		"application/set-payment-initiation": ["setpay"],
-		"application/set-registration-initiation": ["setreg"],
-		"application/shf+xml": ["shf"],
-		"application/sieve": ["siv", "sieve"],
-		"application/smil+xml": ["smi", "smil"],
-		"application/sparql-query": ["rq"],
-		"application/sparql-results+xml": ["srx"],
-		"application/srgs": ["gram"],
-		"application/srgs+xml": ["grxml"],
-		"application/sru+xml": ["sru"],
-		"application/ssdl+xml": ["ssdl"],
-		"application/ssml+xml": ["ssml"],
-		"application/swid+xml": ["swidtag"],
-		"application/tei+xml": ["tei", "teicorpus"],
-		"application/thraud+xml": ["tfi"],
-		"application/timestamped-data": ["tsd"],
-		"application/toml": ["toml"],
-		"application/trig": ["trig"],
-		"application/ttml+xml": ["ttml"],
-		"application/ubjson": ["ubj"],
-		"application/urc-ressheet+xml": ["rsheet"],
-		"application/urc-targetdesc+xml": ["td"],
-		"application/voicexml+xml": ["vxml"],
-		"application/wasm": ["wasm"],
-		"application/widget": ["wgt"],
-		"application/winhlp": ["hlp"],
-		"application/wsdl+xml": ["wsdl"],
-		"application/wspolicy+xml": ["wspolicy"],
-		"application/xaml+xml": ["xaml"],
-		"application/xcap-att+xml": ["xav"],
-		"application/xcap-caps+xml": ["xca"],
-		"application/xcap-diff+xml": ["xdf"],
-		"application/xcap-el+xml": ["xel"],
-		"application/xcap-ns+xml": ["xns"],
-		"application/xenc+xml": ["xenc"],
-		"application/xhtml+xml": ["xhtml", "xht"],
-		"application/xliff+xml": ["xlf"],
-		"application/xml": [
-			"xml",
-			"xsl",
-			"xsd",
-			"rng"
-		],
-		"application/xml-dtd": ["dtd"],
-		"application/xop+xml": ["xop"],
-		"application/xproc+xml": ["xpl"],
-		"application/xslt+xml": ["*xsl", "xslt"],
-		"application/xspf+xml": ["xspf"],
-		"application/xv+xml": [
-			"mxml",
-			"xhvml",
-			"xvml",
-			"xvm"
-		],
-		"application/yang": ["yang"],
-		"application/yin+xml": ["yin"],
-		"application/zip": ["zip"],
-		"audio/3gpp": ["*3gpp"],
-		"audio/adpcm": ["adp"],
-		"audio/amr": ["amr"],
-		"audio/basic": ["au", "snd"],
-		"audio/midi": [
-			"mid",
-			"midi",
-			"kar",
-			"rmi"
-		],
-		"audio/mobile-xmf": ["mxmf"],
-		"audio/mp3": ["*mp3"],
-		"audio/mp4": ["m4a", "mp4a"],
-		"audio/mpeg": [
-			"mpga",
-			"mp2",
-			"mp2a",
-			"mp3",
-			"m2a",
-			"m3a"
-		],
-		"audio/ogg": [
-			"oga",
-			"ogg",
-			"spx",
-			"opus"
-		],
-		"audio/s3m": ["s3m"],
-		"audio/silk": ["sil"],
-		"audio/wav": ["wav"],
-		"audio/wave": ["*wav"],
-		"audio/webm": ["weba"],
-		"audio/xm": ["xm"],
-		"font/collection": ["ttc"],
-		"font/otf": ["otf"],
-		"font/ttf": ["ttf"],
-		"font/woff": ["woff"],
-		"font/woff2": ["woff2"],
-		"image/aces": ["exr"],
-		"image/apng": ["apng"],
-		"image/avif": ["avif"],
-		"image/bmp": ["bmp"],
-		"image/cgm": ["cgm"],
-		"image/dicom-rle": ["drle"],
-		"image/emf": ["emf"],
-		"image/fits": ["fits"],
-		"image/g3fax": ["g3"],
-		"image/gif": ["gif"],
-		"image/heic": ["heic"],
-		"image/heic-sequence": ["heics"],
-		"image/heif": ["heif"],
-		"image/heif-sequence": ["heifs"],
-		"image/hej2k": ["hej2"],
-		"image/hsj2": ["hsj2"],
-		"image/ief": ["ief"],
-		"image/jls": ["jls"],
-		"image/jp2": ["jp2", "jpg2"],
-		"image/jpeg": [
-			"jpeg",
-			"jpg",
-			"jpe"
-		],
-		"image/jph": ["jph"],
-		"image/jphc": ["jhc"],
-		"image/jpm": ["jpm"],
-		"image/jpx": ["jpx", "jpf"],
-		"image/jxr": ["jxr"],
-		"image/jxra": ["jxra"],
-		"image/jxrs": ["jxrs"],
-		"image/jxs": ["jxs"],
-		"image/jxsc": ["jxsc"],
-		"image/jxsi": ["jxsi"],
-		"image/jxss": ["jxss"],
-		"image/ktx": ["ktx"],
-		"image/ktx2": ["ktx2"],
-		"image/png": ["png"],
-		"image/sgi": ["sgi"],
-		"image/svg+xml": ["svg", "svgz"],
-		"image/t38": ["t38"],
-		"image/tiff": ["tif", "tiff"],
-		"image/tiff-fx": ["tfx"],
-		"image/webp": ["webp"],
-		"image/wmf": ["wmf"],
-		"message/disposition-notification": ["disposition-notification"],
-		"message/global": ["u8msg"],
-		"message/global-delivery-status": ["u8dsn"],
-		"message/global-disposition-notification": ["u8mdn"],
-		"message/global-headers": ["u8hdr"],
-		"message/rfc822": ["eml", "mime"],
-		"model/3mf": ["3mf"],
-		"model/gltf+json": ["gltf"],
-		"model/gltf-binary": ["glb"],
-		"model/iges": ["igs", "iges"],
-		"model/mesh": [
-			"msh",
-			"mesh",
-			"silo"
-		],
-		"model/mtl": ["mtl"],
-		"model/obj": ["obj"],
-		"model/step+xml": ["stpx"],
-		"model/step+zip": ["stpz"],
-		"model/step-xml+zip": ["stpxz"],
-		"model/stl": ["stl"],
-		"model/vrml": ["wrl", "vrml"],
-		"model/x3d+binary": ["*x3db", "x3dbz"],
-		"model/x3d+fastinfoset": ["x3db"],
-		"model/x3d+vrml": ["*x3dv", "x3dvz"],
-		"model/x3d+xml": ["x3d", "x3dz"],
-		"model/x3d-vrml": ["x3dv"],
-		"text/cache-manifest": ["appcache", "manifest"],
-		"text/calendar": ["ics", "ifb"],
-		"text/coffeescript": ["coffee", "litcoffee"],
-		"text/css": ["css"],
-		"text/csv": ["csv"],
-		"text/html": [
-			"html",
-			"htm",
-			"shtml"
-		],
-		"text/jade": ["jade"],
-		"text/jsx": ["jsx"],
-		"text/less": ["less"],
-		"text/markdown": ["markdown", "md"],
-		"text/mathml": ["mml"],
-		"text/mdx": ["mdx"],
-		"text/n3": ["n3"],
-		"text/plain": [
-			"txt",
-			"text",
-			"conf",
-			"def",
-			"list",
-			"log",
-			"in",
-			"ini"
-		],
-		"text/richtext": ["rtx"],
-		"text/rtf": ["*rtf"],
-		"text/sgml": ["sgml", "sgm"],
-		"text/shex": ["shex"],
-		"text/slim": ["slim", "slm"],
-		"text/spdx": ["spdx"],
-		"text/stylus": ["stylus", "styl"],
-		"text/tab-separated-values": ["tsv"],
-		"text/troff": [
-			"t",
-			"tr",
-			"roff",
-			"man",
-			"me",
-			"ms"
-		],
-		"text/turtle": ["ttl"],
-		"text/uri-list": [
-			"uri",
-			"uris",
-			"urls"
-		],
-		"text/vcard": ["vcard"],
-		"text/vtt": ["vtt"],
-		"text/xml": ["*xml"],
-		"text/yaml": ["yaml", "yml"],
-		"video/3gpp": ["3gp", "3gpp"],
-		"video/3gpp2": ["3g2"],
-		"video/h261": ["h261"],
-		"video/h263": ["h263"],
-		"video/h264": ["h264"],
-		"video/iso.segment": ["m4s"],
-		"video/jpeg": ["jpgv"],
-		"video/jpm": ["*jpm", "jpgm"],
-		"video/mj2": ["mj2", "mjp2"],
-		"video/mp2t": ["ts"],
-		"video/mp4": [
-			"mp4",
-			"mp4v",
-			"mpg4"
-		],
-		"video/mpeg": [
-			"mpeg",
-			"mpg",
-			"mpe",
-			"m1v",
-			"m2v"
-		],
-		"video/ogg": ["ogv"],
-		"video/quicktime": ["qt", "mov"],
-		"video/webm": ["webm"]
+	const loadBundleRows = async () => bundlesToRows(await loadBundles());
+	const updateBundle = async (bundle) => {
+		const route = routes.update(bundle.id);
+		const response = await fetch(http.buildUrl(route.path), {
+			method: "PATCH",
+			headers: http.headers(route.headers),
+			body: JSON.stringify(bundle)
+		});
+		await http.parseJson(response);
 	};
-}));
+	const createBundles = async (bundles) => {
+		const route = routes.create();
+		const response = await fetch(http.buildUrl(route.path), {
+			method: "POST",
+			headers: http.headers(route.headers),
+			body: JSON.stringify(bundles)
+		});
+		await http.parseJson(response);
+	};
+	const deleteBundle = async (bundleId) => {
+		const route = routes.delete(bundleId);
+		const response = await fetch(http.buildUrl(route.path), {
+			method: "DELETE",
+			headers: http.headers(route.headers)
+		});
+		await http.parseJson(response);
+	};
+	return {
+		createBundle: (bundle) => createBundles([bundle]),
+		createBundles,
+		deleteBundle,
+		deleteChannel,
+		insertChannel,
+		loadBundle,
+		loadBundleRow,
+		loadBundleRows,
+		loadBundles,
+		loadBundleWindow,
+		loadChannels,
+		updateBundle
+	};
+};
 //#endregion
-//#region ../../node_modules/.pnpm/mime@2.6.0/node_modules/mime/types/other.js
-var require_other = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = {
-		"application/prs.cww": ["cww"],
-		"application/vnd.1000minds.decision-model+xml": ["1km"],
-		"application/vnd.3gpp.pic-bw-large": ["plb"],
-		"application/vnd.3gpp.pic-bw-small": ["psb"],
-		"application/vnd.3gpp.pic-bw-var": ["pvb"],
-		"application/vnd.3gpp2.tcap": ["tcap"],
-		"application/vnd.3m.post-it-notes": ["pwn"],
-		"application/vnd.accpac.simply.aso": ["aso"],
-		"application/vnd.accpac.simply.imp": ["imp"],
-		"application/vnd.acucobol": ["acu"],
-		"application/vnd.acucorp": ["atc", "acutc"],
-		"application/vnd.adobe.air-application-installer-package+zip": ["air"],
-		"application/vnd.adobe.formscentral.fcdt": ["fcdt"],
-		"application/vnd.adobe.fxp": ["fxp", "fxpl"],
-		"application/vnd.adobe.xdp+xml": ["xdp"],
-		"application/vnd.adobe.xfdf": ["xfdf"],
-		"application/vnd.ahead.space": ["ahead"],
-		"application/vnd.airzip.filesecure.azf": ["azf"],
-		"application/vnd.airzip.filesecure.azs": ["azs"],
-		"application/vnd.amazon.ebook": ["azw"],
-		"application/vnd.americandynamics.acc": ["acc"],
-		"application/vnd.amiga.ami": ["ami"],
-		"application/vnd.android.package-archive": ["apk"],
-		"application/vnd.anser-web-certificate-issue-initiation": ["cii"],
-		"application/vnd.anser-web-funds-transfer-initiation": ["fti"],
-		"application/vnd.antix.game-component": ["atx"],
-		"application/vnd.apple.installer+xml": ["mpkg"],
-		"application/vnd.apple.keynote": ["key"],
-		"application/vnd.apple.mpegurl": ["m3u8"],
-		"application/vnd.apple.numbers": ["numbers"],
-		"application/vnd.apple.pages": ["pages"],
-		"application/vnd.apple.pkpass": ["pkpass"],
-		"application/vnd.aristanetworks.swi": ["swi"],
-		"application/vnd.astraea-software.iota": ["iota"],
-		"application/vnd.audiograph": ["aep"],
-		"application/vnd.balsamiq.bmml+xml": ["bmml"],
-		"application/vnd.blueice.multipass": ["mpm"],
-		"application/vnd.bmi": ["bmi"],
-		"application/vnd.businessobjects": ["rep"],
-		"application/vnd.chemdraw+xml": ["cdxml"],
-		"application/vnd.chipnuts.karaoke-mmd": ["mmd"],
-		"application/vnd.cinderella": ["cdy"],
-		"application/vnd.citationstyles.style+xml": ["csl"],
-		"application/vnd.claymore": ["cla"],
-		"application/vnd.cloanto.rp9": ["rp9"],
-		"application/vnd.clonk.c4group": [
-			"c4g",
-			"c4d",
-			"c4f",
-			"c4p",
-			"c4u"
-		],
-		"application/vnd.cluetrust.cartomobile-config": ["c11amc"],
-		"application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"],
-		"application/vnd.commonspace": ["csp"],
-		"application/vnd.contact.cmsg": ["cdbcmsg"],
-		"application/vnd.cosmocaller": ["cmc"],
-		"application/vnd.crick.clicker": ["clkx"],
-		"application/vnd.crick.clicker.keyboard": ["clkk"],
-		"application/vnd.crick.clicker.palette": ["clkp"],
-		"application/vnd.crick.clicker.template": ["clkt"],
-		"application/vnd.crick.clicker.wordbank": ["clkw"],
-		"application/vnd.criticaltools.wbs+xml": ["wbs"],
-		"application/vnd.ctc-posml": ["pml"],
-		"application/vnd.cups-ppd": ["ppd"],
-		"application/vnd.curl.car": ["car"],
-		"application/vnd.curl.pcurl": ["pcurl"],
-		"application/vnd.dart": ["dart"],
-		"application/vnd.data-vision.rdz": ["rdz"],
-		"application/vnd.dbf": ["dbf"],
-		"application/vnd.dece.data": [
-			"uvf",
-			"uvvf",
-			"uvd",
-			"uvvd"
-		],
-		"application/vnd.dece.ttml+xml": ["uvt", "uvvt"],
-		"application/vnd.dece.unspecified": ["uvx", "uvvx"],
-		"application/vnd.dece.zip": ["uvz", "uvvz"],
-		"application/vnd.denovo.fcselayout-link": ["fe_launch"],
-		"application/vnd.dna": ["dna"],
-		"application/vnd.dolby.mlp": ["mlp"],
-		"application/vnd.dpgraph": ["dpg"],
-		"application/vnd.dreamfactory": ["dfac"],
-		"application/vnd.ds-keypoint": ["kpxx"],
-		"application/vnd.dvb.ait": ["ait"],
-		"application/vnd.dvb.service": ["svc"],
-		"application/vnd.dynageo": ["geo"],
-		"application/vnd.ecowin.chart": ["mag"],
-		"application/vnd.enliven": ["nml"],
-		"application/vnd.epson.esf": ["esf"],
-		"application/vnd.epson.msf": ["msf"],
-		"application/vnd.epson.quickanime": ["qam"],
-		"application/vnd.epson.salt": ["slt"],
-		"application/vnd.epson.ssf": ["ssf"],
-		"application/vnd.eszigno3+xml": ["es3", "et3"],
-		"application/vnd.ezpix-album": ["ez2"],
-		"application/vnd.ezpix-package": ["ez3"],
-		"application/vnd.fdf": ["fdf"],
-		"application/vnd.fdsn.mseed": ["mseed"],
-		"application/vnd.fdsn.seed": ["seed", "dataless"],
-		"application/vnd.flographit": ["gph"],
-		"application/vnd.fluxtime.clip": ["ftc"],
-		"application/vnd.framemaker": [
-			"fm",
-			"frame",
-			"maker",
-			"book"
-		],
-		"application/vnd.frogans.fnc": ["fnc"],
-		"application/vnd.frogans.ltf": ["ltf"],
-		"application/vnd.fsc.weblaunch": ["fsc"],
-		"application/vnd.fujitsu.oasys": ["oas"],
-		"application/vnd.fujitsu.oasys2": ["oa2"],
-		"application/vnd.fujitsu.oasys3": ["oa3"],
-		"application/vnd.fujitsu.oasysgp": ["fg5"],
-		"application/vnd.fujitsu.oasysprs": ["bh2"],
-		"application/vnd.fujixerox.ddd": ["ddd"],
-		"application/vnd.fujixerox.docuworks": ["xdw"],
-		"application/vnd.fujixerox.docuworks.binder": ["xbd"],
-		"application/vnd.fuzzysheet": ["fzs"],
-		"application/vnd.genomatix.tuxedo": ["txd"],
-		"application/vnd.geogebra.file": ["ggb"],
-		"application/vnd.geogebra.tool": ["ggt"],
-		"application/vnd.geometry-explorer": ["gex", "gre"],
-		"application/vnd.geonext": ["gxt"],
-		"application/vnd.geoplan": ["g2w"],
-		"application/vnd.geospace": ["g3w"],
-		"application/vnd.gmx": ["gmx"],
-		"application/vnd.google-apps.document": ["gdoc"],
-		"application/vnd.google-apps.presentation": ["gslides"],
-		"application/vnd.google-apps.spreadsheet": ["gsheet"],
-		"application/vnd.google-earth.kml+xml": ["kml"],
-		"application/vnd.google-earth.kmz": ["kmz"],
-		"application/vnd.grafeq": ["gqf", "gqs"],
-		"application/vnd.groove-account": ["gac"],
-		"application/vnd.groove-help": ["ghf"],
-		"application/vnd.groove-identity-message": ["gim"],
-		"application/vnd.groove-injector": ["grv"],
-		"application/vnd.groove-tool-message": ["gtm"],
-		"application/vnd.groove-tool-template": ["tpl"],
-		"application/vnd.groove-vcard": ["vcg"],
-		"application/vnd.hal+xml": ["hal"],
-		"application/vnd.handheld-entertainment+xml": ["zmm"],
-		"application/vnd.hbci": ["hbci"],
-		"application/vnd.hhe.lesson-player": ["les"],
-		"application/vnd.hp-hpgl": ["hpgl"],
-		"application/vnd.hp-hpid": ["hpid"],
-		"application/vnd.hp-hps": ["hps"],
-		"application/vnd.hp-jlyt": ["jlt"],
-		"application/vnd.hp-pcl": ["pcl"],
-		"application/vnd.hp-pclxl": ["pclxl"],
-		"application/vnd.hydrostatix.sof-data": ["sfd-hdstx"],
-		"application/vnd.ibm.minipay": ["mpy"],
-		"application/vnd.ibm.modcap": [
-			"afp",
-			"listafp",
-			"list3820"
-		],
-		"application/vnd.ibm.rights-management": ["irm"],
-		"application/vnd.ibm.secure-container": ["sc"],
-		"application/vnd.iccprofile": ["icc", "icm"],
-		"application/vnd.igloader": ["igl"],
-		"application/vnd.immervision-ivp": ["ivp"],
-		"application/vnd.immervision-ivu": ["ivu"],
-		"application/vnd.insors.igm": ["igm"],
-		"application/vnd.intercon.formnet": ["xpw", "xpx"],
-		"application/vnd.intergeo": ["i2g"],
-		"application/vnd.intu.qbo": ["qbo"],
-		"application/vnd.intu.qfx": ["qfx"],
-		"application/vnd.ipunplugged.rcprofile": ["rcprofile"],
-		"application/vnd.irepository.package+xml": ["irp"],
-		"application/vnd.is-xpr": ["xpr"],
-		"application/vnd.isac.fcs": ["fcs"],
-		"application/vnd.jam": ["jam"],
-		"application/vnd.jcp.javame.midlet-rms": ["rms"],
-		"application/vnd.jisp": ["jisp"],
-		"application/vnd.joost.joda-archive": ["joda"],
-		"application/vnd.kahootz": ["ktz", "ktr"],
-		"application/vnd.kde.karbon": ["karbon"],
-		"application/vnd.kde.kchart": ["chrt"],
-		"application/vnd.kde.kformula": ["kfo"],
-		"application/vnd.kde.kivio": ["flw"],
-		"application/vnd.kde.kontour": ["kon"],
-		"application/vnd.kde.kpresenter": ["kpr", "kpt"],
-		"application/vnd.kde.kspread": ["ksp"],
-		"application/vnd.kde.kword": ["kwd", "kwt"],
-		"application/vnd.kenameaapp": ["htke"],
-		"application/vnd.kidspiration": ["kia"],
-		"application/vnd.kinar": ["kne", "knp"],
-		"application/vnd.koan": [
-			"skp",
-			"skd",
-			"skt",
-			"skm"
-		],
-		"application/vnd.kodak-descriptor": ["sse"],
-		"application/vnd.las.las+xml": ["lasxml"],
-		"application/vnd.llamagraphics.life-balance.desktop": ["lbd"],
-		"application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"],
-		"application/vnd.lotus-1-2-3": ["123"],
-		"application/vnd.lotus-approach": ["apr"],
-		"application/vnd.lotus-freelance": ["pre"],
-		"application/vnd.lotus-notes": ["nsf"],
-		"application/vnd.lotus-organizer": ["org"],
-		"application/vnd.lotus-screencam": ["scm"],
-		"application/vnd.lotus-wordpro": ["lwp"],
-		"application/vnd.macports.portpkg": ["portpkg"],
-		"application/vnd.mapbox-vector-tile": ["mvt"],
-		"application/vnd.mcd": ["mcd"],
-		"application/vnd.medcalcdata": ["mc1"],
-		"application/vnd.mediastation.cdkey": ["cdkey"],
-		"application/vnd.mfer": ["mwf"],
-		"application/vnd.mfmp": ["mfm"],
-		"application/vnd.micrografx.flo": ["flo"],
-		"application/vnd.micrografx.igx": ["igx"],
-		"application/vnd.mif": ["mif"],
-		"application/vnd.mobius.daf": ["daf"],
-		"application/vnd.mobius.dis": ["dis"],
-		"application/vnd.mobius.mbk": ["mbk"],
-		"application/vnd.mobius.mqy": ["mqy"],
-		"application/vnd.mobius.msl": ["msl"],
-		"application/vnd.mobius.plc": ["plc"],
-		"application/vnd.mobius.txf": ["txf"],
-		"application/vnd.mophun.application": ["mpn"],
-		"application/vnd.mophun.certificate": ["mpc"],
-		"application/vnd.mozilla.xul+xml": ["xul"],
-		"application/vnd.ms-artgalry": ["cil"],
-		"application/vnd.ms-cab-compressed": ["cab"],
-		"application/vnd.ms-excel": [
-			"xls",
-			"xlm",
-			"xla",
-			"xlc",
-			"xlt",
-			"xlw"
-		],
-		"application/vnd.ms-excel.addin.macroenabled.12": ["xlam"],
-		"application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"],
-		"application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"],
-		"application/vnd.ms-excel.template.macroenabled.12": ["xltm"],
-		"application/vnd.ms-fontobject": ["eot"],
-		"application/vnd.ms-htmlhelp": ["chm"],
-		"application/vnd.ms-ims": ["ims"],
-		"application/vnd.ms-lrm": ["lrm"],
-		"application/vnd.ms-officetheme": ["thmx"],
-		"application/vnd.ms-outlook": ["msg"],
-		"application/vnd.ms-pki.seccat": ["cat"],
-		"application/vnd.ms-pki.stl": ["*stl"],
-		"application/vnd.ms-powerpoint": [
-			"ppt",
-			"pps",
-			"pot"
-		],
-		"application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"],
-		"application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"],
-		"application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"],
-		"application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"],
-		"application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"],
-		"application/vnd.ms-project": ["mpp", "mpt"],
-		"application/vnd.ms-word.document.macroenabled.12": ["docm"],
-		"application/vnd.ms-word.template.macroenabled.12": ["dotm"],
-		"application/vnd.ms-works": [
-			"wps",
-			"wks",
-			"wcm",
-			"wdb"
-		],
-		"application/vnd.ms-wpl": ["wpl"],
-		"application/vnd.ms-xpsdocument": ["xps"],
-		"application/vnd.mseq": ["mseq"],
-		"application/vnd.musician": ["mus"],
-		"application/vnd.muvee.style": ["msty"],
-		"application/vnd.mynfc": ["taglet"],
-		"application/vnd.neurolanguage.nlu": ["nlu"],
-		"application/vnd.nitf": ["ntf", "nitf"],
-		"application/vnd.noblenet-directory": ["nnd"],
-		"application/vnd.noblenet-sealer": ["nns"],
-		"application/vnd.noblenet-web": ["nnw"],
-		"application/vnd.nokia.n-gage.ac+xml": ["*ac"],
-		"application/vnd.nokia.n-gage.data": ["ngdat"],
-		"application/vnd.nokia.n-gage.symbian.install": ["n-gage"],
-		"application/vnd.nokia.radio-preset": ["rpst"],
-		"application/vnd.nokia.radio-presets": ["rpss"],
-		"application/vnd.novadigm.edm": ["edm"],
-		"application/vnd.novadigm.edx": ["edx"],
-		"application/vnd.novadigm.ext": ["ext"],
-		"application/vnd.oasis.opendocument.chart": ["odc"],
-		"application/vnd.oasis.opendocument.chart-template": ["otc"],
-		"application/vnd.oasis.opendocument.database": ["odb"],
-		"application/vnd.oasis.opendocument.formula": ["odf"],
-		"application/vnd.oasis.opendocument.formula-template": ["odft"],
-		"application/vnd.oasis.opendocument.graphics": ["odg"],
-		"application/vnd.oasis.opendocument.graphics-template": ["otg"],
-		"application/vnd.oasis.opendocument.image": ["odi"],
-		"application/vnd.oasis.opendocument.image-template": ["oti"],
-		"application/vnd.oasis.opendocument.presentation": ["odp"],
-		"application/vnd.oasis.opendocument.presentation-template": ["otp"],
-		"application/vnd.oasis.opendocument.spreadsheet": ["ods"],
-		"application/vnd.oasis.opendocument.spreadsheet-template": ["ots"],
-		"application/vnd.oasis.opendocument.text": ["odt"],
-		"application/vnd.oasis.opendocument.text-master": ["odm"],
-		"application/vnd.oasis.opendocument.text-template": ["ott"],
-		"application/vnd.oasis.opendocument.text-web": ["oth"],
-		"application/vnd.olpc-sugar": ["xo"],
-		"application/vnd.oma.dd2+xml": ["dd2"],
-		"application/vnd.openblox.game+xml": ["obgx"],
-		"application/vnd.openofficeorg.extension": ["oxt"],
-		"application/vnd.openstreetmap.data+xml": ["osm"],
-		"application/vnd.openxmlformats-officedocument.presentationml.presentation": ["pptx"],
-		"application/vnd.openxmlformats-officedocument.presentationml.slide": ["sldx"],
-		"application/vnd.openxmlformats-officedocument.presentationml.slideshow": ["ppsx"],
-		"application/vnd.openxmlformats-officedocument.presentationml.template": ["potx"],
-		"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ["xlsx"],
-		"application/vnd.openxmlformats-officedocument.spreadsheetml.template": ["xltx"],
-		"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ["docx"],
-		"application/vnd.openxmlformats-officedocument.wordprocessingml.template": ["dotx"],
-		"application/vnd.osgeo.mapguide.package": ["mgp"],
-		"application/vnd.osgi.dp": ["dp"],
-		"application/vnd.osgi.subsystem": ["esa"],
-		"application/vnd.palm": [
-			"pdb",
-			"pqa",
-			"oprc"
-		],
-		"application/vnd.pawaafile": ["paw"],
-		"application/vnd.pg.format": ["str"],
-		"application/vnd.pg.osasli": ["ei6"],
-		"application/vnd.picsel": ["efif"],
-		"application/vnd.pmi.widget": ["wg"],
-		"application/vnd.pocketlearn": ["plf"],
-		"application/vnd.powerbuilder6": ["pbd"],
-		"application/vnd.previewsystems.box": ["box"],
-		"application/vnd.proteus.magazine": ["mgz"],
-		"application/vnd.publishare-delta-tree": ["qps"],
-		"application/vnd.pvi.ptid1": ["ptid"],
-		"application/vnd.quark.quarkxpress": [
-			"qxd",
-			"qxt",
-			"qwd",
-			"qwt",
-			"qxl",
-			"qxb"
-		],
-		"application/vnd.rar": ["rar"],
-		"application/vnd.realvnc.bed": ["bed"],
-		"application/vnd.recordare.musicxml": ["mxl"],
-		"application/vnd.recordare.musicxml+xml": ["musicxml"],
-		"application/vnd.rig.cryptonote": ["cryptonote"],
-		"application/vnd.rim.cod": ["cod"],
-		"application/vnd.rn-realmedia": ["rm"],
-		"application/vnd.rn-realmedia-vbr": ["rmvb"],
-		"application/vnd.route66.link66+xml": ["link66"],
-		"application/vnd.sailingtracker.track": ["st"],
-		"application/vnd.seemail": ["see"],
-		"application/vnd.sema": ["sema"],
-		"application/vnd.semd": ["semd"],
-		"application/vnd.semf": ["semf"],
-		"application/vnd.shana.informed.formdata": ["ifm"],
-		"application/vnd.shana.informed.formtemplate": ["itp"],
-		"application/vnd.shana.informed.interchange": ["iif"],
-		"application/vnd.shana.informed.package": ["ipk"],
-		"application/vnd.simtech-mindmapper": ["twd", "twds"],
-		"application/vnd.smaf": ["mmf"],
-		"application/vnd.smart.teacher": ["teacher"],
-		"application/vnd.software602.filler.form+xml": ["fo"],
-		"application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"],
-		"application/vnd.spotfire.dxp": ["dxp"],
-		"application/vnd.spotfire.sfs": ["sfs"],
-		"application/vnd.stardivision.calc": ["sdc"],
-		"application/vnd.stardivision.draw": ["sda"],
-		"application/vnd.stardivision.impress": ["sdd"],
-		"application/vnd.stardivision.math": ["smf"],
-		"application/vnd.stardivision.writer": ["sdw", "vor"],
-		"application/vnd.stardivision.writer-global": ["sgl"],
-		"application/vnd.stepmania.package": ["smzip"],
-		"application/vnd.stepmania.stepchart": ["sm"],
-		"application/vnd.sun.wadl+xml": ["wadl"],
-		"application/vnd.sun.xml.calc": ["sxc"],
-		"application/vnd.sun.xml.calc.template": ["stc"],
-		"application/vnd.sun.xml.draw": ["sxd"],
-		"application/vnd.sun.xml.draw.template": ["std"],
-		"application/vnd.sun.xml.impress": ["sxi"],
-		"application/vnd.sun.xml.impress.template": ["sti"],
-		"application/vnd.sun.xml.math": ["sxm"],
-		"application/vnd.sun.xml.writer": ["sxw"],
-		"application/vnd.sun.xml.writer.global": ["sxg"],
-		"application/vnd.sun.xml.writer.template": ["stw"],
-		"application/vnd.sus-calendar": ["sus", "susp"],
-		"application/vnd.svd": ["svd"],
-		"application/vnd.symbian.install": ["sis", "sisx"],
-		"application/vnd.syncml+xml": ["xsm"],
-		"application/vnd.syncml.dm+wbxml": ["bdm"],
-		"application/vnd.syncml.dm+xml": ["xdm"],
-		"application/vnd.syncml.dmddf+xml": ["ddf"],
-		"application/vnd.tao.intent-module-archive": ["tao"],
-		"application/vnd.tcpdump.pcap": [
-			"pcap",
-			"cap",
-			"dmp"
-		],
-		"application/vnd.tmobile-livetv": ["tmo"],
-		"application/vnd.trid.tpt": ["tpt"],
-		"application/vnd.triscape.mxs": ["mxs"],
-		"application/vnd.trueapp": ["tra"],
-		"application/vnd.ufdl": ["ufd", "ufdl"],
-		"application/vnd.uiq.theme": ["utz"],
-		"application/vnd.umajin": ["umj"],
-		"application/vnd.unity": ["unityweb"],
-		"application/vnd.uoml+xml": ["uoml"],
-		"application/vnd.vcx": ["vcx"],
-		"application/vnd.visio": [
-			"vsd",
-			"vst",
-			"vss",
-			"vsw"
-		],
-		"application/vnd.visionary": ["vis"],
-		"application/vnd.vsf": ["vsf"],
-		"application/vnd.wap.wbxml": ["wbxml"],
-		"application/vnd.wap.wmlc": ["wmlc"],
-		"application/vnd.wap.wmlscriptc": ["wmlsc"],
-		"application/vnd.webturbo": ["wtb"],
-		"application/vnd.wolfram.player": ["nbp"],
-		"application/vnd.wordperfect": ["wpd"],
-		"application/vnd.wqd": ["wqd"],
-		"application/vnd.wt.stf": ["stf"],
-		"application/vnd.xara": ["xar"],
-		"application/vnd.xfdl": ["xfdl"],
-		"application/vnd.yamaha.hv-dic": ["hvd"],
-		"application/vnd.yamaha.hv-script": ["hvs"],
-		"application/vnd.yamaha.hv-voice": ["hvp"],
-		"application/vnd.yamaha.openscoreformat": ["osf"],
-		"application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"],
-		"application/vnd.yamaha.smaf-audio": ["saf"],
-		"application/vnd.yamaha.smaf-phrase": ["spf"],
-		"application/vnd.yellowriver-custom-menu": ["cmp"],
-		"application/vnd.zul": ["zir", "zirz"],
-		"application/vnd.zzazz.deck+xml": ["zaz"],
-		"application/x-7z-compressed": ["7z"],
-		"application/x-abiword": ["abw"],
-		"application/x-ace-compressed": ["ace"],
-		"application/x-apple-diskimage": ["*dmg"],
-		"application/x-arj": ["arj"],
-		"application/x-authorware-bin": [
-			"aab",
-			"x32",
-			"u32",
-			"vox"
-		],
-		"application/x-authorware-map": ["aam"],
-		"application/x-authorware-seg": ["aas"],
-		"application/x-bcpio": ["bcpio"],
-		"application/x-bdoc": ["*bdoc"],
-		"application/x-bittorrent": ["torrent"],
-		"application/x-blorb": ["blb", "blorb"],
-		"application/x-bzip": ["bz"],
-		"application/x-bzip2": ["bz2", "boz"],
-		"application/x-cbr": [
-			"cbr",
-			"cba",
-			"cbt",
-			"cbz",
-			"cb7"
-		],
-		"application/x-cdlink": ["vcd"],
-		"application/x-cfs-compressed": ["cfs"],
-		"application/x-chat": ["chat"],
-		"application/x-chess-pgn": ["pgn"],
-		"application/x-chrome-extension": ["crx"],
-		"application/x-cocoa": ["cco"],
-		"application/x-conference": ["nsc"],
-		"application/x-cpio": ["cpio"],
-		"application/x-csh": ["csh"],
-		"application/x-debian-package": ["*deb", "udeb"],
-		"application/x-dgc-compressed": ["dgc"],
-		"application/x-director": [
-			"dir",
-			"dcr",
-			"dxr",
-			"cst",
-			"cct",
-			"cxt",
-			"w3d",
-			"fgd",
-			"swa"
-		],
-		"application/x-doom": ["wad"],
-		"application/x-dtbncx+xml": ["ncx"],
-		"application/x-dtbook+xml": ["dtb"],
-		"application/x-dtbresource+xml": ["res"],
-		"application/x-dvi": ["dvi"],
-		"application/x-envoy": ["evy"],
-		"application/x-eva": ["eva"],
-		"application/x-font-bdf": ["bdf"],
-		"application/x-font-ghostscript": ["gsf"],
-		"application/x-font-linux-psf": ["psf"],
-		"application/x-font-pcf": ["pcf"],
-		"application/x-font-snf": ["snf"],
-		"application/x-font-type1": [
-			"pfa",
-			"pfb",
-			"pfm",
-			"afm"
-		],
-		"application/x-freearc": ["arc"],
-		"application/x-futuresplash": ["spl"],
-		"application/x-gca-compressed": ["gca"],
-		"application/x-glulx": ["ulx"],
-		"application/x-gnumeric": ["gnumeric"],
-		"application/x-gramps-xml": ["gramps"],
-		"application/x-gtar": ["gtar"],
-		"application/x-hdf": ["hdf"],
-		"application/x-httpd-php": ["php"],
-		"application/x-install-instructions": ["install"],
-		"application/x-iso9660-image": ["*iso"],
-		"application/x-iwork-keynote-sffkey": ["*key"],
-		"application/x-iwork-numbers-sffnumbers": ["*numbers"],
-		"application/x-iwork-pages-sffpages": ["*pages"],
-		"application/x-java-archive-diff": ["jardiff"],
-		"application/x-java-jnlp-file": ["jnlp"],
-		"application/x-keepass2": ["kdbx"],
-		"application/x-latex": ["latex"],
-		"application/x-lua-bytecode": ["luac"],
-		"application/x-lzh-compressed": ["lzh", "lha"],
-		"application/x-makeself": ["run"],
-		"application/x-mie": ["mie"],
-		"application/x-mobipocket-ebook": ["prc", "mobi"],
-		"application/x-ms-application": ["application"],
-		"application/x-ms-shortcut": ["lnk"],
-		"application/x-ms-wmd": ["wmd"],
-		"application/x-ms-wmz": ["wmz"],
-		"application/x-ms-xbap": ["xbap"],
-		"application/x-msaccess": ["mdb"],
-		"application/x-msbinder": ["obd"],
-		"application/x-mscardfile": ["crd"],
-		"application/x-msclip": ["clp"],
-		"application/x-msdos-program": ["*exe"],
-		"application/x-msdownload": [
-			"*exe",
-			"*dll",
-			"com",
-			"bat",
-			"*msi"
-		],
-		"application/x-msmediaview": [
-			"mvb",
-			"m13",
-			"m14"
-		],
-		"application/x-msmetafile": [
-			"*wmf",
-			"*wmz",
-			"*emf",
-			"emz"
-		],
-		"application/x-msmoney": ["mny"],
-		"application/x-mspublisher": ["pub"],
-		"application/x-msschedule": ["scd"],
-		"application/x-msterminal": ["trm"],
-		"application/x-mswrite": ["wri"],
-		"application/x-netcdf": ["nc", "cdf"],
-		"application/x-ns-proxy-autoconfig": ["pac"],
-		"application/x-nzb": ["nzb"],
-		"application/x-perl": ["pl", "pm"],
-		"application/x-pilot": ["*prc", "*pdb"],
-		"application/x-pkcs12": ["p12", "pfx"],
-		"application/x-pkcs7-certificates": ["p7b", "spc"],
-		"application/x-pkcs7-certreqresp": ["p7r"],
-		"application/x-rar-compressed": ["*rar"],
-		"application/x-redhat-package-manager": ["rpm"],
-		"application/x-research-info-systems": ["ris"],
-		"application/x-sea": ["sea"],
-		"application/x-sh": ["sh"],
-		"application/x-shar": ["shar"],
-		"application/x-shockwave-flash": ["swf"],
-		"application/x-silverlight-app": ["xap"],
-		"application/x-sql": ["sql"],
-		"application/x-stuffit": ["sit"],
-		"application/x-stuffitx": ["sitx"],
-		"application/x-subrip": ["srt"],
-		"application/x-sv4cpio": ["sv4cpio"],
-		"application/x-sv4crc": ["sv4crc"],
-		"application/x-t3vm-image": ["t3"],
-		"application/x-tads": ["gam"],
-		"application/x-tar": ["tar"],
-		"application/x-tcl": ["tcl", "tk"],
-		"application/x-tex": ["tex"],
-		"application/x-tex-tfm": ["tfm"],
-		"application/x-texinfo": ["texinfo", "texi"],
-		"application/x-tgif": ["*obj"],
-		"application/x-ustar": ["ustar"],
-		"application/x-virtualbox-hdd": ["hdd"],
-		"application/x-virtualbox-ova": ["ova"],
-		"application/x-virtualbox-ovf": ["ovf"],
-		"application/x-virtualbox-vbox": ["vbox"],
-		"application/x-virtualbox-vbox-extpack": ["vbox-extpack"],
-		"application/x-virtualbox-vdi": ["vdi"],
-		"application/x-virtualbox-vhd": ["vhd"],
-		"application/x-virtualbox-vmdk": ["vmdk"],
-		"application/x-wais-source": ["src"],
-		"application/x-web-app-manifest+json": ["webapp"],
-		"application/x-x509-ca-cert": [
-			"der",
-			"crt",
-			"pem"
-		],
-		"application/x-xfig": ["fig"],
-		"application/x-xliff+xml": ["*xlf"],
-		"application/x-xpinstall": ["xpi"],
-		"application/x-xz": ["xz"],
-		"application/x-zmachine": [
-			"z1",
-			"z2",
-			"z3",
-			"z4",
-			"z5",
-			"z6",
-			"z7",
-			"z8"
-		],
-		"audio/vnd.dece.audio": ["uva", "uvva"],
-		"audio/vnd.digital-winds": ["eol"],
-		"audio/vnd.dra": ["dra"],
-		"audio/vnd.dts": ["dts"],
-		"audio/vnd.dts.hd": ["dtshd"],
-		"audio/vnd.lucent.voice": ["lvp"],
-		"audio/vnd.ms-playready.media.pya": ["pya"],
-		"audio/vnd.nuera.ecelp4800": ["ecelp4800"],
-		"audio/vnd.nuera.ecelp7470": ["ecelp7470"],
-		"audio/vnd.nuera.ecelp9600": ["ecelp9600"],
-		"audio/vnd.rip": ["rip"],
-		"audio/x-aac": ["aac"],
-		"audio/x-aiff": [
-			"aif",
-			"aiff",
-			"aifc"
-		],
-		"audio/x-caf": ["caf"],
-		"audio/x-flac": ["flac"],
-		"audio/x-m4a": ["*m4a"],
-		"audio/x-matroska": ["mka"],
-		"audio/x-mpegurl": ["m3u"],
-		"audio/x-ms-wax": ["wax"],
-		"audio/x-ms-wma": ["wma"],
-		"audio/x-pn-realaudio": ["ram", "ra"],
-		"audio/x-pn-realaudio-plugin": ["rmp"],
-		"audio/x-realaudio": ["*ra"],
-		"audio/x-wav": ["*wav"],
-		"chemical/x-cdx": ["cdx"],
-		"chemical/x-cif": ["cif"],
-		"chemical/x-cmdf": ["cmdf"],
-		"chemical/x-cml": ["cml"],
-		"chemical/x-csml": ["csml"],
-		"chemical/x-xyz": ["xyz"],
-		"image/prs.btif": ["btif"],
-		"image/prs.pti": ["pti"],
-		"image/vnd.adobe.photoshop": ["psd"],
-		"image/vnd.airzip.accelerator.azv": ["azv"],
-		"image/vnd.dece.graphic": [
-			"uvi",
-			"uvvi",
-			"uvg",
-			"uvvg"
-		],
-		"image/vnd.djvu": ["djvu", "djv"],
-		"image/vnd.dvb.subtitle": ["*sub"],
-		"image/vnd.dwg": ["dwg"],
-		"image/vnd.dxf": ["dxf"],
-		"image/vnd.fastbidsheet": ["fbs"],
-		"image/vnd.fpx": ["fpx"],
-		"image/vnd.fst": ["fst"],
-		"image/vnd.fujixerox.edmics-mmr": ["mmr"],
-		"image/vnd.fujixerox.edmics-rlc": ["rlc"],
-		"image/vnd.microsoft.icon": ["ico"],
-		"image/vnd.ms-dds": ["dds"],
-		"image/vnd.ms-modi": ["mdi"],
-		"image/vnd.ms-photo": ["wdp"],
-		"image/vnd.net-fpx": ["npx"],
-		"image/vnd.pco.b16": ["b16"],
-		"image/vnd.tencent.tap": ["tap"],
-		"image/vnd.valve.source.texture": ["vtf"],
-		"image/vnd.wap.wbmp": ["wbmp"],
-		"image/vnd.xiff": ["xif"],
-		"image/vnd.zbrush.pcx": ["pcx"],
-		"image/x-3ds": ["3ds"],
-		"image/x-cmu-raster": ["ras"],
-		"image/x-cmx": ["cmx"],
-		"image/x-freehand": [
-			"fh",
-			"fhc",
-			"fh4",
-			"fh5",
-			"fh7"
-		],
-		"image/x-icon": ["*ico"],
-		"image/x-jng": ["jng"],
-		"image/x-mrsid-image": ["sid"],
-		"image/x-ms-bmp": ["*bmp"],
-		"image/x-pcx": ["*pcx"],
-		"image/x-pict": ["pic", "pct"],
-		"image/x-portable-anymap": ["pnm"],
-		"image/x-portable-bitmap": ["pbm"],
-		"image/x-portable-graymap": ["pgm"],
-		"image/x-portable-pixmap": ["ppm"],
-		"image/x-rgb": ["rgb"],
-		"image/x-tga": ["tga"],
-		"image/x-xbitmap": ["xbm"],
-		"image/x-xpixmap": ["xpm"],
-		"image/x-xwindowdump": ["xwd"],
-		"message/vnd.wfa.wsc": ["wsc"],
-		"model/vnd.collada+xml": ["dae"],
-		"model/vnd.dwf": ["dwf"],
-		"model/vnd.gdl": ["gdl"],
-		"model/vnd.gtw": ["gtw"],
-		"model/vnd.mts": ["mts"],
-		"model/vnd.opengex": ["ogex"],
-		"model/vnd.parasolid.transmit.binary": ["x_b"],
-		"model/vnd.parasolid.transmit.text": ["x_t"],
-		"model/vnd.sap.vds": ["vds"],
-		"model/vnd.usdz+zip": ["usdz"],
-		"model/vnd.valve.source.compiled-map": ["bsp"],
-		"model/vnd.vtu": ["vtu"],
-		"text/prs.lines.tag": ["dsc"],
-		"text/vnd.curl": ["curl"],
-		"text/vnd.curl.dcurl": ["dcurl"],
-		"text/vnd.curl.mcurl": ["mcurl"],
-		"text/vnd.curl.scurl": ["scurl"],
-		"text/vnd.dvb.subtitle": ["sub"],
-		"text/vnd.fly": ["fly"],
-		"text/vnd.fmi.flexstor": ["flx"],
-		"text/vnd.graphviz": ["gv"],
-		"text/vnd.in3d.3dml": ["3dml"],
-		"text/vnd.in3d.spot": ["spot"],
-		"text/vnd.sun.j2me.app-descriptor": ["jad"],
-		"text/vnd.wap.wml": ["wml"],
-		"text/vnd.wap.wmlscript": ["wmls"],
-		"text/x-asm": ["s", "asm"],
-		"text/x-c": [
-			"c",
-			"cc",
-			"cxx",
-			"cpp",
-			"h",
-			"hh",
-			"dic"
-		],
-		"text/x-component": ["htc"],
-		"text/x-fortran": [
-			"f",
-			"for",
-			"f77",
-			"f90"
-		],
-		"text/x-handlebars-template": ["hbs"],
-		"text/x-java-source": ["java"],
-		"text/x-lua": ["lua"],
-		"text/x-markdown": ["mkd"],
-		"text/x-nfo": ["nfo"],
-		"text/x-opml": ["opml"],
-		"text/x-org": ["*org"],
-		"text/x-pascal": ["p", "pas"],
-		"text/x-processing": ["pde"],
-		"text/x-sass": ["sass"],
-		"text/x-scss": ["scss"],
-		"text/x-setext": ["etx"],
-		"text/x-sfv": ["sfv"],
-		"text/x-suse-ymp": ["ymp"],
-		"text/x-uuencode": ["uu"],
-		"text/x-vcalendar": ["vcs"],
-		"text/x-vcard": ["vcf"],
-		"video/vnd.dece.hd": ["uvh", "uvvh"],
-		"video/vnd.dece.mobile": ["uvm", "uvvm"],
-		"video/vnd.dece.pd": ["uvp", "uvvp"],
-		"video/vnd.dece.sd": ["uvs", "uvvs"],
-		"video/vnd.dece.video": ["uvv", "uvvv"],
-		"video/vnd.dvb.file": ["dvb"],
-		"video/vnd.fvt": ["fvt"],
-		"video/vnd.mpegurl": ["mxu", "m4u"],
-		"video/vnd.ms-playready.media.pyv": ["pyv"],
-		"video/vnd.uvvu.mp4": ["uvu", "uvvu"],
-		"video/vnd.vivo": ["viv"],
-		"video/x-f4v": ["f4v"],
-		"video/x-fli": ["fli"],
-		"video/x-flv": ["flv"],
-		"video/x-m4v": ["m4v"],
-		"video/x-matroska": [
-			"mkv",
-			"mk3d",
-			"mks"
-		],
-		"video/x-mng": ["mng"],
-		"video/x-ms-asf": ["asf", "asx"],
-		"video/x-ms-vob": ["vob"],
-		"video/x-ms-wm": ["wm"],
-		"video/x-ms-wmv": ["wmv"],
-		"video/x-ms-wmx": ["wmx"],
-		"video/x-ms-wvx": ["wvx"],
-		"video/x-msvideo": ["avi"],
-		"video/x-sgi-movie": ["movie"],
-		"video/x-smv": ["smv"],
-		"x-conference/x-cooltalk": ["ice"]
+//#region src/standaloneReleaseRemote.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const data = (value, message) => {
+	if (!isRecord(value) || !("data" in value)) throw new StandaloneDatabaseError("invalid-response", message);
+	return value.data;
+};
+const createStandaloneReleaseRemote = (config) => {
+	const http = createStandaloneHttp(config);
+	const headers = () => http.headers({ "Cache-Control": "no-cache" });
+	return {
+		async findReleaseById(id) {
+			const response = await fetch(http.buildUrl(`/releases/${encodeURIComponent(id)}`), { headers: headers() });
+			if (response.status === 404) return null;
+			return data(await http.parseJson(response), "Invalid Release response.");
+		},
+		async findReleasesByScope(input) {
+			const url = new URL(http.buildUrl("/releases"));
+			url.searchParams.set("scopeKey", input.scopeKey);
+			url.searchParams.set("limit", String(input.limit));
+			if (input.afterReleaseId !== void 0) url.searchParams.set("afterReleaseId", input.afterReleaseId);
+			const response = await fetch(url, { headers: headers() });
+			const rows = data(await http.parseJson(response), "Invalid Release list response.");
+			if (!Array.isArray(rows)) throw new StandaloneDatabaseError("invalid-response", "Invalid Release list response.", response.status);
+			return rows;
+		},
+		async findReleases(input) {
+			const url = new URL(http.buildUrl("/releases"));
+			url.searchParams.set("limit", String(input.limit));
+			for (const [key, value] of Object.entries(input)) if (key !== "limit" && value !== void 0) url.searchParams.set(key, String(value));
+			const response = await fetch(url, { headers: headers() });
+			const rows = data(await http.parseJson(response), "Invalid Release list response.");
+			if (!Array.isArray(rows)) throw new StandaloneDatabaseError("invalid-response", "Invalid Release list response.", response.status);
+			return rows;
+		},
+		async findCatalogByScopeKey(scopeKey) {
+			const response = await fetch(http.buildUrl(`/release-catalogs/${encodeURIComponent(scopeKey)}`), { headers: headers() });
+			if (response.status === 404) return null;
+			return data(await http.parseJson(response), "Invalid Release catalog response.");
+		},
+		async findCatalogs(input) {
+			const url = new URL(http.buildUrl("/release-catalogs"));
+			url.searchParams.set("limit", String(input.limit));
+			if (input.afterScopeKey !== void 0) url.searchParams.set("afterScopeKey", input.afterScopeKey);
+			const response = await fetch(url, { headers: headers() });
+			const rows = data(await http.parseJson(response), "Invalid Release catalog list response.");
+			if (!Array.isArray(rows)) throw new StandaloneDatabaseError("invalid-response", "Invalid Release catalog list response.", response.status);
+			return rows;
+		},
+		async commit(input) {
+			const response = await fetch(http.buildUrl("/database/commit"), {
+				body: JSON.stringify(input),
+				headers: http.headers(),
+				method: "POST"
+			});
+			return data(await http.parseJson(response), "Invalid database commit response.");
+		}
 	};
-}));
+};
+//#endregion
+//#region src/standaloneRepository.ts
+const toBundleWhere = (where) => {
+	if (!where) return [];
+	const filters = [];
+	if (where.platform !== void 0) filters.push({
+		field: "platform",
+		value: where.platform
+	});
+	if (where.id?.eq !== void 0) filters.push({
+		field: "id",
+		value: where.id.eq
+	});
+	if (where.id?.gt !== void 0) filters.push({
+		field: "id",
+		operator: "gt",
+		value: where.id.gt
+	});
+	if (where.id?.gte !== void 0) filters.push({
+		field: "id",
+		operator: "gte",
+		value: where.id.gte
+	});
+	if (where.id?.lt !== void 0) filters.push({
+		field: "id",
+		operator: "lt",
+		value: where.id.lt
+	});
+	if (where.id?.lte !== void 0) filters.push({
+		field: "id",
+		operator: "lte",
+		value: where.id.lte
+	});
+	if (where.id?.in !== void 0) filters.push({
+		field: "id",
+		operator: "in",
+		value: where.id.in
+	});
+	return filters;
+};
+/**
+* Bundle-only HTTP repository used by the CLI for a self-hosted server.
+*
+* This is intentionally not a database plugin: insights and access-key
+* persistence belong to the server's database provider.
+*/
+const standaloneRepository = (config) => {
+	const remote = createStandaloneBundleRemote(config);
+	const releaseRemote = createStandaloneReleaseRemote(config);
+	const bundleReader = createStandaloneBundleReader(remote);
+	return Object.freeze({
+		name: "standalone-repository",
+		models: {
+			bundles: {
+				async findById(id) {
+					return await bundleReader.findOne({
+						model: "bundles",
+						where: [{
+							field: "id",
+							value: id
+						}]
+					});
+				},
+				async findMany(query) {
+					return await bundleReader.findMany({
+						model: "bundles",
+						where: toBundleWhere(query.where),
+						limit: query.limit,
+						offset: query.offset,
+						orderBy: [query.orderBy]
+					});
+				},
+				count: (where) => bundleReader.count({
+					model: "bundles",
+					where: toBundleWhere(where)
+				})
+			},
+			bundlePatches: { async findByBundleIds(bundleIds) {
+				if (bundleIds.length === 0) return [];
+				return await bundleReader.findMany({
+					model: "bundle_patches",
+					where: [{
+						field: "bundle_id",
+						operator: "in",
+						value: bundleIds
+					}],
+					orderBy: [{
+						field: "id",
+						direction: "asc"
+					}],
+					limit: Number.MAX_SAFE_INTEGER,
+					offset: 0
+				});
+			} },
+			releases: {
+				findById: (id) => releaseRemote.findReleaseById(id),
+				findMany: (input) => releaseRemote.findReleases(input),
+				findManyByScope: (input) => releaseRemote.findReleasesByScope(input)
+			},
+			releaseCatalogs: {
+				findByScopeKey: (scopeKey) => releaseRemote.findCatalogByScopeKey(scopeKey),
+				findMany: (input) => releaseRemote.findCatalogs(input)
+			},
+			channels: {
+				insert: (input) => remote.insertChannel(input),
+				delete: (input) => remote.deleteChannel(input),
+				async list() {
+					return { channels: await remote.loadChannels() };
+				}
+			}
+		},
+		commit: (input) => releaseRemote.commit(input)
+	});
+};
 //#endregion
 //#region src/standaloneStorage.ts
-var import_mime = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = new (require_Mime())(require_standard(), require_other());
-})))(), 1);
 const defaultRoutes = {
-	upload: (_key, _filePath) => ({ path: "/upload" }),
-	delete: (_storageUri) => ({ path: "/delete" }),
-	readText: (_storageUri) => ({ path: "/readText" }),
-	getDownloadUrl: (_storageUri) => ({ path: "/getDownloadUrl" })
+	put: () => ({ path: "/upload" }),
+	get: () => ({ path: "/get" }),
+	exists: () => ({ path: "/exists" }),
+	delete: () => ({ path: "/delete" })
 };
 const createRoute = (defaultRoute, customRoute) => ({
 	path: customRoute?.path ?? defaultRoute.path,
@@ -1504,103 +675,69 @@ const createRoute = (defaultRoute, customRoute) => ({
 		...customRoute?.headers
 	}
 });
-const standaloneStorage = (config, hooks) => () => {
-	const routes = {
-		upload: (key, filePath) => createRoute(defaultRoutes.upload(key, filePath), config.routes?.upload?.(key, filePath)),
-		delete: (storageUri) => createRoute(defaultRoutes.delete(storageUri), config.routes?.delete?.(storageUri)),
-		readText: (storageUri) => createRoute(defaultRoutes.readText(storageUri), config.routes?.readText?.(storageUri)),
-		getDownloadUrl: (storageUri) => createRoute(defaultRoutes.getDownloadUrl(storageUri), config.routes?.getDownloadUrl?.(storageUri))
-	};
+const standaloneStorage = (config) => {
 	const getHeaders = (routeHeaders) => ({
 		...config.commonHeaders,
 		...routeHeaders
 	});
-	return {
-		name: "standaloneStorage",
-		supportedProtocol: "http",
-		profiles: {
-			node: {
-				async delete(storageUri) {
-					const { path: routePath, headers: routeHeaders } = routes.delete(storageUri);
-					const response = await fetch(`${config.baseUrl}${routePath}`, {
-						method: "DELETE",
-						headers: getHeaders(routeHeaders),
-						body: JSON.stringify({ storageUri })
-					});
-					if (!response.ok) {
-						const error = /* @__PURE__ */ new Error(`Failed to delete bundle: ${response.statusText}`);
-						console.error(error);
-						throw error;
-					}
-				},
-				async upload(key, filePath) {
-					const fileContent = await fs.readFile(filePath);
-					const contentType = import_mime.default.getType(filePath) ?? "application/octet-stream";
-					const filename = path.basename(filePath);
-					const { path: routePath, headers: routeHeaders } = routes.upload(key, filePath);
-					const formData = new FormData();
-					formData.append("file", new Blob([fileContent], { type: contentType }), filename);
-					formData.append("key", key);
-					const response = await fetch(`${config.baseUrl}${routePath}`, {
-						method: "POST",
-						headers: getHeaders(routeHeaders),
-						body: formData
-					});
-					if (!response.ok) {
-						const error = `Failed to upload bundle: ${response.statusText}`;
-						console.error(`[upload] ${error}`);
-						throw new Error(error);
-					}
-					const result = await response.json();
-					if (!result.storageUri) {
-						const error = "Failed to upload bundle - no storageUri in response";
-						console.error(`[upload] ${error}`);
-						throw new Error(error);
-					}
-					await hooks?.onStorageUploaded?.();
-					return { storageUri: result.storageUri };
-				},
-				async exists(storageUri) {
-					const { fileUrl } = await getDownloadUrl(storageUri);
-					return (await fetch(fileUrl, { method: "HEAD" })).ok;
-				},
-				async downloadFile(storageUri, filePath) {
-					const { fileUrl } = await getDownloadUrl(storageUri);
-					const response = await fetch(fileUrl);
-					if (!response.ok) throw new Error(`Failed to download bundle: ${response.statusText}`);
-					await fs.mkdir(path.dirname(filePath), { recursive: true });
-					await fs.writeFile(filePath, new Uint8Array(await response.arrayBuffer()));
-				}
-			},
-			runtime: {
-				async readText(storageUri) {
-					const { path: routePath, headers: routeHeaders } = routes.readText(storageUri);
-					const response = await fetch(`${config.baseUrl}${routePath}`, {
-						method: "POST",
-						headers: getHeaders(routeHeaders),
-						body: JSON.stringify({ storageUri })
-					});
-					if (!response.ok) return null;
-					return response.text();
-				},
-				getDownloadUrl
-			}
-		}
+	const resolveRoute = (name, args) => {
+		const fallback = defaultRoutes[name];
+		const custom = config.routes?.[name];
+		return createRoute(fallback(...args), custom?.(...args));
 	};
-	async function getDownloadUrl(storageUri) {
-		const { path: routePath, headers: routeHeaders } = routes.getDownloadUrl(storageUri);
-		const response = await fetch(`${config.baseUrl}${routePath}`, {
-			method: "POST",
-			headers: getHeaders(routeHeaders),
+	const requestStorageUri = async (routeName, storageUri) => {
+		parseStorageUri(storageUri, config.protocol);
+		const { path, headers } = resolveRoute(routeName, [{ storageUri }]);
+		const response = await fetch(`${config.baseUrl}${path}`, {
+			method: routeName === "delete" ? "DELETE" : "POST",
+			headers: {
+				"content-type": "application/json",
+				...getHeaders(headers)
+			},
 			body: JSON.stringify({ storageUri })
 		});
-		if (!response.ok) {
-			const error = /* @__PURE__ */ new Error(`Failed to get download URL: ${response.statusText}`);
-			console.error(error);
-			throw error;
+		if (!response.ok && response.status !== 404) throw new Error(`Failed to ${routeName} storage object: ${response.statusText}`);
+		return response;
+	};
+	return createStoragePlugin({
+		name: "standaloneStorage",
+		protocol: config.protocol,
+		async put({ key, body, contentType, contentLength }) {
+			const { path, headers } = resolveRoute("put", [{
+				key,
+				contentLength,
+				contentType
+			}]);
+			const bytes = await new Response(body).arrayBuffer();
+			if (contentLength !== void 0 && bytes.byteLength !== contentLength) throw new Error(`Storage upload length mismatch: expected ${contentLength}, got ${bytes.byteLength}`);
+			const formData = new FormData();
+			formData.append("file", new Blob([bytes], { type: contentType }), key.split("/").at(-1) ?? "object");
+			formData.append("key", key);
+			const response = await fetch(`${config.baseUrl}${path}`, {
+				method: "POST",
+				headers: getHeaders(headers),
+				body: formData
+			});
+			if (!response.ok) throw new Error(`Failed to upload bundle: ${response.statusText}`);
+			const result = await response.json();
+			if (!result.storageUri) throw new Error("Storage server returned an empty storage URI");
+			parseStorageUri(result.storageUri, config.protocol);
+			return { storageUri: result.storageUri };
+		},
+		async get({ storageUri }) {
+			const response = await requestStorageUri("get", storageUri);
+			return { response: response.status === 404 ? null : response };
+		},
+		async exists({ storageUri }) {
+			const response = await requestStorageUri("exists", storageUri);
+			if (response.status === 404) return { exists: false };
+			return { exists: (await response.json()).exists };
+		},
+		async delete({ storageUri }) {
+			await requestStorageUri("delete", storageUri);
+			return { deleted: true };
 		}
-		return { fileUrl: (await response.json()).fileUrl };
-	}
+	});
 };
 //#endregion
-export { standaloneRepository, standaloneStorage };
+export { StandaloneDatabaseError, standaloneRepository, standaloneStorage };