@hot-updater/standalone 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/index.mjs

@@ -1,226 +1,4 @@
-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;
-				}
-				const rows = queryStandaloneRows(await loadRows(remote, "bundles"), { where });
-				return countDistinctRows(rows, input.distinct);
-			}
-			case "bundle_patches": {
-				const rows = queryStandaloneRows(await loadRows(remote, "bundle_patches"), { where: input.where });
-				return countDistinctRows(rows, 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";
-				}
-				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
+import { DatabaseBundleNotFoundError, ReleaseCatalogMutationError, ReleaseManagementError, createStorageAdapter, parseStorageUri } from "@hot-updater/plugin-core";
 //#region src/standaloneHttp.ts
 var StandaloneDatabaseError = class extends Error {
 	code;
@@ -232,7 +10,7 @@ var StandaloneDatabaseError = class extends Error {
 		this.status = status;
 	}
 };
-const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const createStandaloneHttp = (config) => {
 	const baseUrl = config.baseUrl.replace(/\/+$/, "");
 	const buildUrl = (path) => `${baseUrl}${path}`;
@@ -245,8 +23,8 @@ const createStandaloneHttp = (config) => {
 		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;
+			if (isRecord$1(body) && typeof body.message === "string") message = body.message;
+			else if (isRecord$1(body) && typeof body.error === "string") message = body.error;
 		} catch (error) {
 			if (!(error instanceof SyntaxError)) throw error;
 		}
@@ -260,409 +38,206 @@ const createStandaloneHttp = (config) => {
 			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
+		parseJson
 	};
 };
 //#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;
+//#region src/standaloneCore.ts
+/** The admin API protocol this client speaks; the server's `/version` must report it or a later one. */
+const STANDALONE_ADMIN_PROTOCOL = 2;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const MANAGEMENT_CODES = /* @__PURE__ */ new Set([
+	"ENABLED_RELEASE",
+	"RELEASE_NOT_FOUND",
+	"SCOPE_MOVE_UNSUPPORTED",
+	"TARGET_RELEASE_INVALID",
+	"VERSION_CONFLICT"
+]);
+const CATALOG_CODES = /* @__PURE__ */ new Set([
+	"CATALOG_GENERATION_EXHAUSTED",
+	"CATALOG_IDENTITY_MISSING",
+	"INVALID_SCOPE",
+	"NON_MONOTONIC_RELEASE_ID"
+]);
+/** A refusal the server named, as the error core throws in process; anything else as a request failure. */
+const refusal = (status, value, fallback) => {
+	const code = isRecord(value) ? value.code : void 0;
+	const message = isRecord(value) && typeof value.error === "string" ? value.error : fallback;
+	if (typeof code === "string" && MANAGEMENT_CODES.has(code)) return new ReleaseManagementError(code, message);
+	if (typeof code === "string" && CATALOG_CODES.has(code)) return new ReleaseCatalogMutationError(code, message);
+	if (code === "BUNDLE_NOT_FOUND" && isRecord(value)) {
+		const id = /"([^"]+)"/u.exec(message)?.[1] ?? "";
+		return new DatabaseBundleNotFoundError(id);
 	}
-	return true;
-};
-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/standaloneRoutes.ts
-function bundlePath(bundleId) {
-	return `/bundles/${encodeURIComponent(bundleId)}`;
-}
-function channelPath(channelId) {
-	return `/channels/${encodeURIComponent(channelId)}`;
-}
-const defaultRoutes$1 = {
-	create: () => ({ path: "/bundles" }),
-	update: (bundleId) => ({ path: bundlePath(bundleId) }),
-	list: () => ({
-		path: "/bundles",
-		headers: { "Cache-Control": "no-cache" }
-	}),
-	channels: () => ({
-		path: "/channels",
-		headers: { "Cache-Control": "no-cache" }
-	}),
-	deleteChannel: (channelId) => ({
-		path: channelPath(channelId),
-		headers: {}
-	}),
-	retrieve: (bundleId) => ({
-		path: bundlePath(bundleId),
-		headers: { Accept: "application/json" }
-	}),
-	delete: (bundleId) => ({ path: bundlePath(bundleId) })
+	return new StandaloneDatabaseError("request-failed", message, status);
 };
-const createRoute$1 = (defaultRoute, customRoute) => ({
-	path: customRoute?.path ?? defaultRoute.path,
-	headers: {
-		...defaultRoute.headers,
-		...customRoute?.headers
-	}
+const keysetParams = ({ order, after, limit }) => ({
+	v: String(2),
+	limit: String(limit),
+	...order === void 0 ? {} : { order },
+	...after === void 0 ? {} : { cursor: after }
 });
-//#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 filterParams = (filter) => {
+	switch (filter.kind) {
+		case "all": return {};
+		case "bundle": return { bundleId: filter.bundleId };
+		case "scope": return {
+			scopeKey: filter.scopeKey,
+			...filter.enabled === void 0 ? {} : { enabled: String(filter.enabled) }
 		};
-		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);
-		const bundles = pageAligned ? value.data : value.data.slice(input.offset, input.offset + input.limit);
-		return {
-			rows: await bundlesToRows(bundles),
-			total: value.pagination.total
+		case "channelPlatform": return {
+			channelId: filter.channelId,
+			platform: filter.platform,
+			...filter.enabled === void 0 ? {} : { enabled: String(filter.enabled) }
 		};
+	}
+};
+/**
+* Core's API over a self-hosted server's admin handler, protocol 2: the CLI's
+* path to a database it cannot open itself. The first call checks that the
+* server speaks protocol 2, so an older server fails fast.
+*/
+const createStandaloneCoreApi = (config) => {
+	const http = createStandaloneHttp(config);
+	let checked;
+	const checkProtocol = async () => {
+		const response = await fetch(http.buildUrl("/version"), { headers: http.headers({ "Cache-Control": "no-cache" }) });
+		const body = response.status === 404 ? {} : await http.parseJson(response);
+		const protocol = isRecord(body) ? body.adminProtocol : void 0;
+		if (typeof protocol !== "number" || protocol < 2) throw new StandaloneDatabaseError("request-failed", `The server at ${config.baseUrl} speaks admin API protocol ${typeof protocol === "number" ? protocol : 1}, and this CLI needs 2. Upgrade @hot-updater/server on the server.`, response.status);
 	};
-	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)
+	/** One admin request's JSON body, or null for 204 and for a GET that finds nothing; `/version` is checked once before the first. */
+	const request = async (method, path, { query = {}, body } = {}) => {
+		checked ??= checkProtocol().catch((error) => {
+			checked = void 0;
+			throw error;
 		});
-		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)
+		await checked;
+		const url = new URL(http.buildUrl(path));
+		for (const [key, value] of Object.entries(query)) url.searchParams.set(key, value);
+		const response = await fetch(url, {
+			method,
+			headers: http.headers(method === "GET" ? { "Cache-Control": "no-cache" } : void 0),
+			...body === void 0 ? {} : { body: JSON.stringify(body) }
 		});
-		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 (response.status === 204) return null;
+		if (method === "GET" && response.status === 404) return null;
+		if (response.status === 503) throw new StandaloneDatabaseError("request-failed", `The server at ${config.baseUrl} answered ${method} ${path} with 503: its database is not ready. If it needs migrations, run \`hot-updater db migrate\` where the server's database is configured.`, 503);
+		if (!response.ok) {
+			const failure = await response.json().catch(() => null);
+			throw refusal(response.status, failure, `${method} ${path} failed with status ${response.status}.`);
 		}
-		if (!hasChannelDeleteResult(value)) throw new StandaloneDatabaseError("invalid-response", "Invalid Channel delete response.", response.status);
-		return value.data;
-	};
-	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);
+		if (!isRecord(value)) throw new StandaloneDatabaseError("invalid-response", `The server answered ${method} ${path} with no JSON object.`, response.status);
 		return value;
 	};
-	const loadBundleRow = async (bundleId) => {
-		const bundle = await loadBundle(bundleId);
-		return bundle ? (await bundlesToRows([bundle]))[0] ?? null : null;
-	};
-	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
+	/** A request's `data`, or null when it found nothing. */
+	const call = async (...args) => {
+		const value = await request(...args);
+		if (value === null) return null;
+		if (!("data" in value)) throw new StandaloneDatabaseError("invalid-response", `The server answered ${args[0]} ${args[1]} without data.`);
+		return value.data;
 	};
-};
-//#endregion
-//#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" });
+	const list = async (path, query) => await call("GET", path, { query }) ?? [];
+	const v2 = { v: String(2) };
+	const encode = encodeURIComponent;
 	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.");
+		ready: async () => {
+			await list("/release-catalogs", {
+				...v2,
+				limit: "1"
+			});
 		},
-		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;
+		getBundle: (id) => call("GET", `/bundles/${encode(id)}`, { query: v2 }),
+		listBundles: ({ platform, ...input }) => list("/bundles", {
+			...keysetParams(input),
+			...platform === void 0 ? {} : { platform }
+		}),
+		countBundles: async (platform) => {
+			const total = await call("GET", "/bundles/count", { query: {
+				...v2,
+				...platform === void 0 ? {} : { platform }
+			} });
+			if (typeof total !== "number") throw new StandaloneDatabaseError("invalid-response", "The server answered a bundle count without a number.");
+			return total;
 		},
-		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;
+		countBundleChildren: async (baseBundleIds) => {
+			const ids = [...new Set(baseBundleIds)];
+			if (ids.length === 0) return {};
+			return await call("GET", "/bundles/child-counts", { query: {
+				...v2,
+				ids: ids.join(",")
+			} }) ?? {};
 		},
-		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.");
+		listPatchesFromBase: (baseBundleId, input) => list(`/bundles/${encode(baseBundleId)}/children`, keysetParams(input)),
+		findBaseBundleIds: (candidateKey, bundleId, limit) => list(`/base-candidates/${encode(candidateKey)}`, {
+			before: bundleId,
+			limit: String(limit)
+		}),
+		getRelease: (id) => call("GET", `/releases/${encode(id)}`),
+		listReleases: ({ filter, ...input }) => list("/releases", {
+			...keysetParams(input),
+			...filterParams(filter)
+		}),
+		getReleaseCatalogRow: (scopeKey) => call("GET", `/release-catalogs/${encode(scopeKey)}`),
+		listReleaseCatalogs: (input) => list("/release-catalogs", keysetParams(input)),
+		listChannels: () => list("/channels", v2),
+		findChannelByName: (name) => call("GET", "/channels", { query: {
+			...v2,
+			name
+		} }),
+		deploy: async (deployments) => await call("POST", "/releases", { body: { deployments } }),
+		updateReleasePolicy: async ({ releaseId, ...input }) => await call("PATCH", `/releases/${encode(releaseId)}`, { body: input }),
+		preflightReleasePolicy: async ({ releaseId, ...input }) => await call("POST", `/releases/${encode(releaseId)}/preflight`, { body: input }),
+		deleteRelease: async ({ releaseId, expectedRevision }) => await call("DELETE", `/releases/${encode(releaseId)}`, { query: {
+			confirm: releaseId,
+			...expectedRevision === void 0 ? {} : { expectedRevision: String(expectedRevision) }
+		} }),
+		promoteRelease: async ({ releaseId, ...input }) => await call("POST", `/releases/${encode(releaseId)}/promote`, { body: input }),
+		rebuildReleaseCatalog: async (scopeKey) => await call("POST", `/release-catalogs/${encode(scopeKey)}/rebuild`),
+		preflightReleaseCatalogRebuild: async (scopeKey) => await call("POST", `/release-catalogs/${encode(scopeKey)}/preflight`),
+		ensureChannel: async (name) => await call("POST", "/channels", {
+			query: v2,
+			body: { name }
+		}),
+		deleteChannel: async (id) => {
+			return await call("DELETE", `/channels/${encode(id)}`).catch((error) => {
+				if (error instanceof StandaloneDatabaseError && error.status === 409) return {
+					deleted: false,
+					reason: "not_empty"
+				};
+				if (error instanceof StandaloneDatabaseError && error.status === 404) return {
+					deleted: false,
+					reason: "not_found"
+				};
+				throw error;
+			}) ?? { deleted: true };
 		},
-		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;
+		updateBundle: async (id, update) => {
+			await request("PATCH", `/bundles/${encode(id)}`, { body: update });
 		},
-		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.");
+		deleteBundles: async (ids) => {
+			await request("POST", "/bundles/delete", { body: { ids } });
 		}
 	};
 };
 //#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.
+* A self-hosted server's database for the CLI and console: core's API over
+* the server's admin API protocol 2, and GETs on its admin handler for the
+* routes core does not cover, which its plugins serve. Plugins' tables belong
+* to the server's own database.
 */
 const standaloneRepository = (config) => {
-	const remote = createStandaloneBundleRemote(config);
-	const releaseRemote = createStandaloneReleaseRemote(config);
-	const bundleReader = createStandaloneBundleReader(remote);
+	const http = createStandaloneHttp(config);
 	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)
+		core: createStandaloneCoreApi(config),
+		fetchAdmin: (path) => fetch(http.buildUrl(path), { headers: http.headers({ "Cache-Control": "no-cache" }) })
 	});
 };
 //#endregion
@@ -704,7 +279,7 @@ const standaloneStorage = (config) => {
 		if (!response.ok && response.status !== 404) throw new Error(`Failed to ${routeName} storage object: ${response.statusText}`);
 		return response;
 	};
-	return createStoragePlugin({
+	return createStorageAdapter({
 		name: "standaloneStorage",
 		protocol: config.protocol,
 		async put({ key, body, contentType, contentLength }) {
@@ -745,4 +320,4 @@ const standaloneStorage = (config) => {
 	});
 };
 //#endregion
-export { StandaloneDatabaseError, standaloneRepository, standaloneStorage };
+export { STANDALONE_ADMIN_PROTOCOL, StandaloneDatabaseError, createStandaloneCoreApi, standaloneRepository, standaloneStorage };