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

package/dist/adapters/prisma.mjs

@@ -1,276 +1,44 @@
-import { getHotUpdaterSchemaVersion, hotUpdaterSchema } from "../db/schema/registry.mjs";
-import { generatePrismaSchema } from "../db/schemaGenerators.mjs";
-import { isChannelDeleteReferencedError, translateChannelDeleteError } from "./databaseConstraintErrors.mjs";
-import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils.mjs";
-import { createPrismaOrderBy, createPrismaWhere } from "./prismaQuery.mjs";
-import { PrismaAdapterError, getPrismaDelegate, parsePrismaApiKeyRow, parsePrismaBundleEventRow, parsePrismaBundleRow, parsePrismaChannelRow, parsePrismaInsightsInstallationRow, parsePrismaPatchRow, parsePrismaReleaseCatalogRow, parsePrismaReleaseRow, parsePrismaRows } from "./prismaRows.mjs";
-import { DatabasePluginInputError, createDatabasePlugin } from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+import { checkSqlProvider } from "./sqlProviders.mjs";
+import { generatePrismaEngineSchema, prismaCollationStatements } from "../db/enginePrismaSchema.mjs";
+import { prismaExecutor } from "./prismaExecutor.mjs";
+import { coreSettings, coreTarget, createEngineDatabase, createSettingsMigrator, createSqlAdapter } from "@hot-updater/plugin-core";
 //#region src/adapters/prisma.ts
-const hasCallbackTransaction = (client) => "$transaction" in client && typeof client.$transaction === "function";
-const runPrismaTransaction = (client, isolationLevel, callback, retryUniqueConflict = false) => {
-	const execute = () => isolationLevel === "serializable" ? client.$transaction(callback, { isolationLevel: "Serializable" }) : client.$transaction(callback);
-	if (isolationLevel === "default") return execute();
-	return (async () => {
-		for (let attempt = 0;; attempt += 1) try {
-			return await execute();
-		} catch (error) {
-			if (attempt >= 2 || typeof error !== "object" || error === null || !("code" in error) || error.code !== "P2034" && !(retryUniqueConflict && error.code === "P2002")) throw error;
-		}
-	})();
-};
-const assertPrismaProvider = (provider) => {
-	if (provider === "mongodb") throw new PrismaAdapterError("Prisma adapter does not support MongoDB; use mongodbAdapter instead");
-};
-const findMany = async (client, input, provider) => {
-	if (input.distinctOn !== void 0) throw new DatabasePluginInputError("invalid-operation");
-	const rawOrderBy = input.orderBy;
-	const orderBy = createPrismaOrderBy(rawOrderBy);
-	const rows = rawOrderBy !== void 0 && hasNullOrderOverrides(rawOrderBy) ? sortRowsByOrder(await getPrismaDelegate(client, input.model).findMany({ where: createPrismaWhere(input.where, provider) }), rawOrderBy).slice(input.offset, input.offset + input.limit) : await getPrismaDelegate(client, input.model).findMany({
-		where: createPrismaWhere(input.where, provider),
-		...orderBy ? { orderBy } : {},
-		skip: input.offset,
-		take: input.limit
-	});
-	switch (input.model) {
-		case "bundles": return parsePrismaRows(rows, parsePrismaBundleRow);
-		case "bundle_patches": return parsePrismaRows(rows, parsePrismaPatchRow);
-		case "bundle_events": return parsePrismaRows(rows, parsePrismaBundleEventRow);
-		case "bundle_installations": return parsePrismaRows(rows, parsePrismaInsightsInstallationRow);
-		case "channels": return parsePrismaRows(rows, parsePrismaChannelRow);
-		case "api_keys": return parsePrismaRows(rows, parsePrismaApiKeyRow);
-		case "releases": return parsePrismaRows(rows, parsePrismaReleaseRow);
-		case "release_catalogs": return parsePrismaRows(rows, parsePrismaReleaseCatalogRow);
-	}
-};
-const assertPatchReferences = async (client, bundleId, baseBundleId) => {
-	const ids = Array.from(/* @__PURE__ */ new Set([bundleId, baseBundleId]));
-	if (await getPrismaDelegate(client, "bundles").count({ where: { id: { in: ids } } }) !== ids.length) throw new PrismaAdapterError("patch references a missing bundle");
-};
-const createCrudImplementation = (client, provider, relationMode) => ({
-	deleteChannel: async ({ id }) => {
-		const channels = getPrismaDelegate(client, "channels");
-		if (await channels.findFirst({ where: { id } }) === null) return {
-			deleted: false,
-			reason: "not_found"
-		};
-		if (await getPrismaDelegate(client, "releases").count({ where: { channel_id: id } }) > 0) return {
-			deleted: false,
-			reason: "not_empty"
-		};
-		try {
-			await channels.deleteMany({ where: { id } });
-		} catch (error) {
-			if (isChannelDeleteReferencedError(error)) return {
-				deleted: false,
-				reason: "not_empty"
+/**
+* Hot Updater's database on a Prisma client: the storage engine through the
+* shared SQL core, fenced by the schema settings. `db generate` writes the
+* models Prisma applies; `db migrate` then sets the collations Prisma cannot
+* declare and writes the settings rows the fence checks.
+*/
+const prismaAdapter = (config) => {
+	const provider = checkSqlProvider("prismaAdapter", config.provider);
+	const executor = prismaExecutor(config.prisma, provider);
+	return {
+		...createEngineDatabase({
+			name: "prisma",
+			adapter: createSqlAdapter({ executor })
+		}),
+		provider,
+		generateSchema: ((version, _name, { schema } = coreTarget) => {
+			if (version !== "latest" && version !== coreSettings["schema.core"]) throw new Error(`Invalid version ${version}`);
+			return {
+				code: generatePrismaEngineSchema(provider, schema),
+				path: "prisma/schema.prisma"
 			};
-			throw error;
-		}
-		return { deleted: true };
-	},
-	insertChannel: async (input) => {
-		const delegate = getPrismaDelegate(client, "channels");
-		const existing = await delegate.findFirst({ where: { name: input.row.name } });
-		if (existing !== null) return {
-			row: parsePrismaChannelRow(existing),
-			inserted: false
-		};
-		const row = parsePrismaChannelRow(await delegate.upsert({
-			where: { name: input.row.name },
-			create: input.row,
-			update: {}
-		}));
-		return {
-			row,
-			inserted: row.id === input.row.id
-		};
-	},
-	create: async (input) => {
-		if (input.model === "bundle_patches") await assertPatchReferences(client, input.data.bundle_id, input.data.base_bundle_id);
-		const delegate = getPrismaDelegate(client, input.model);
-		let row;
-		if (input.onConflict === "ignore") {
-			const where = input.model === "channels" ? { name: input.data.name } : input.model === "api_keys" ? { hash: input.data.hash } : { install_id: input.data.install_id };
-			row = await delegate.upsert({
-				where,
-				create: input.data,
-				update: {}
-			});
-		} else row = await delegate.create({ data: input.data });
-		switch (input.model) {
-			case "bundles": return parsePrismaBundleRow(row);
-			case "bundle_patches": return parsePrismaPatchRow(row);
-			case "bundle_events": return parsePrismaBundleEventRow(row);
-			case "bundle_installations": return parsePrismaInsightsInstallationRow(row);
-			case "channels": return parsePrismaChannelRow(row);
-			case "api_keys": return parsePrismaApiKeyRow(row);
-			case "releases": return parsePrismaReleaseRow(row);
-			case "release_catalogs": return parsePrismaReleaseCatalogRow(row);
-		}
-	},
-	update: async (input) => {
-		if (input.model === "bundle_installations") {
-			const installId = input.where.find((item) => item.field === "install_id" && (item.operator === void 0 || item.operator === "eq") && typeof item.value === "string")?.value;
-			if (typeof installId !== "string") throw new PrismaAdapterError("bundle_installations update requires install_id");
-			const delegate = getPrismaDelegate(client, "bundle_installations");
-			if (delegate.updateMany === void 0) throw new PrismaAdapterError("model delegate \"bundle_installations\" requires updateMany");
-			if ((await delegate.updateMany({
-				where: createPrismaWhere(input.where, provider),
-				data: input.update
-			})).count === 0) return null;
-			const stored = await delegate.findFirst({ where: { install_id: installId } });
-			return stored === null ? null : parsePrismaInsightsInstallationRow(stored);
-		}
-		const id = input.where[0]?.value;
-		if (typeof id !== "string") throw new PrismaAdapterError(`${input.model} update requires a string id`);
-		if (input.model === "api_keys") {
-			const delegate = getPrismaDelegate(client, "api_keys");
-			if (await delegate.findFirst({ where: { id } }) === null) return null;
-			await delegate.update({
-				where: { id },
-				data: input.update
-			});
-			const stored = await delegate.findFirst({ where: { id } });
-			return stored === null ? null : parsePrismaApiKeyRow(stored);
-		}
-		if (input.model === "releases") {
-			const delegate = getPrismaDelegate(client, "releases");
-			if (await delegate.findFirst({ where: { id } }) === null) return null;
-			await delegate.update({
-				where: { id },
-				data: input.update
-			});
-			const stored = await delegate.findFirst({ where: { id } });
-			return stored === null ? null : parsePrismaReleaseRow(stored);
-		}
-		if (input.model === "release_catalogs") {
-			const delegate = getPrismaDelegate(client, "release_catalogs");
-			if (await delegate.findFirst({ where: { scope_key: id } }) === null) return null;
-			await delegate.update({
-				where: { scope_key: id },
-				data: input.update
+		}),
+		createMigrator: ({ schema, settings } = coreTarget) => {
+			const collations = prismaCollationStatements(provider, schema);
+			return createSettingsMigrator({
+				adapterName: "prisma",
+				executor,
+				settings,
+				applyTables: "`prisma db push` (or `prisma migrate`)",
+				...collations.length === 0 ? {} : { fixups: {
+					description: "Set the collations Prisma cannot declare, so strings compare by their bytes",
+					statements: collations
+				} }
 			});
-			const stored = await delegate.findFirst({ where: { scope_key: id } });
-			return stored === null ? null : parsePrismaReleaseCatalogRow(stored);
-		}
-		const delegate = getPrismaDelegate(client, "bundles");
-		if (delegate.updateMany === void 0) throw new PrismaAdapterError("model delegate \"bundles\" requires updateMany");
-		if (await delegate.findFirst({ where: { id } }) === null) return null;
-		await delegate.updateMany({
-			where: { id },
-			data: input.update
-		});
-		const stored = await delegate.findFirst({ where: { id } });
-		if (stored === null) return null;
-		return parsePrismaBundleRow(stored);
-	},
-	delete: async (input) => {
-		if (input.model === "bundles" && relationMode === "prisma") {
-			const rows = await getPrismaDelegate(client, "bundles").findMany({ where: createPrismaWhere(input.where, provider) });
-			const ids = parsePrismaRows(rows, parsePrismaBundleRow).map(({ id }) => id);
-			if (ids.length === 0) return;
-			await getPrismaDelegate(client, "bundle_patches").deleteMany({ where: { OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }] } });
-		}
-		try {
-			await getPrismaDelegate(client, input.model).deleteMany({ where: createPrismaWhere(input.where, provider) });
-		} catch (error) {
-			if (input.model === "channels") translateChannelDeleteError(error);
-			throw error;
-		}
-	},
-	count: async (input) => {
-		if (input.distinct !== void 0) throw new DatabasePluginInputError("invalid-operation");
-		return getPrismaDelegate(client, input.model).count({ where: createPrismaWhere(input.where, provider) });
-	},
-	findOne: async (input) => {
-		const row = await getPrismaDelegate(client, input.model).findFirst({ where: createPrismaWhere(input.where, provider) });
-		if (row === null) return null;
-		switch (input.model) {
-			case "bundles": return parsePrismaBundleRow(row);
-			case "bundle_patches": return parsePrismaPatchRow(row);
-			case "channels": return parsePrismaChannelRow(row);
-			case "api_keys": return parsePrismaApiKeyRow(row);
-			case "releases": return parsePrismaReleaseRow(row);
-			case "release_catalogs": return parsePrismaReleaseCatalogRow(row);
-			case "bundle_installations": return parsePrismaInsightsInstallationRow(row);
 		}
-	},
-	findMany: (input) => findMany(client, input, provider)
-});
-const createPrismaImplementation = (client, relationMode, provider) => {
-	const crud = createCrudImplementation(client, provider, relationMode);
-	const implementation = {
-		...crud,
-		recordInsights: (input) => {
-			if (!hasCallbackTransaction(client)) throw new PrismaAdapterError("Insights recording requires callback transactions");
-			return runPrismaTransaction(client, "serializable", async (transactionClient) => {
-				const events = getPrismaDelegate(transactionClient, "bundle_events");
-				if (await events.findFirst({ where: { id: input.event.id } }) !== null) return;
-				await events.create({ data: input.event });
-				const installations = getPrismaDelegate(transactionClient, "bundle_installations");
-				const existing = await installations.findFirst({ where: { install_id: input.installation.install_id } });
-				if (existing === null) {
-					await installations.create({ data: input.installation });
-					return;
-				}
-				const current = parsePrismaInsightsInstallationRow(existing);
-				if (current.received_at_ms > input.installation.received_at_ms || current.received_at_ms === input.installation.received_at_ms && current.id >= input.installation.id) return;
-				await installations.update({
-					where: { install_id: input.installation.install_id },
-					data: input.installation
-				});
-			}, true);
-		},
-		deleteChannel: (input) => {
-			if (!hasCallbackTransaction(client)) throw new PrismaAdapterError("channel deletion requires callback transactions");
-			return runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).deleteChannel(input));
-		},
-		delete: (input) => {
-			if (input.model !== "bundles" || relationMode === "foreign-keys") return crud.delete(input);
-			if (!hasCallbackTransaction(client)) throw new PrismaAdapterError("relation mode \"prisma\" requires callback transactions");
-			return runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).delete(input));
-		}
-	};
-	if (relationMode === "prisma" && !hasCallbackTransaction(client)) throw new PrismaAdapterError("relation mode \"prisma\" requires callback transactions");
-	if (!hasCallbackTransaction(client)) return implementation;
-	if (relationMode === "prisma") implementation.create = (input) => runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).create(input));
-	implementation.update = (input) => runPrismaTransaction(client, relationMode === "prisma" ? "serializable" : "default", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).update(input));
-	return {
-		...implementation,
-		transaction: (callback) => runPrismaTransaction(client, "serializable", async (transactionClient) => {
-			return callback(createCrudImplementation(transactionClient, provider, relationMode));
-		})
-	};
-};
-const prismaAdapter = (config) => {
-	assertPrismaProvider(config.provider);
-	const adapter = createDatabasePluginAdapter("prisma", createPrismaImplementation(config.prisma, config.relationMode ?? "foreign-keys", config.provider));
-	const unsupportedMssqlInsights = async () => {
-		throw new PrismaAdapterError("SQL Server Insights is unsupported: string keys pad trailing spaces and do not provide the required exact UTF-8 identity ordering");
 	};
-	const insights = config.provider === "mssql" ? {
-		record: unsupportedMssqlInsights,
-		listEvents: unsupportedMssqlInsights,
-		findInstallations: unsupportedMssqlInsights,
-		countInstallations: unsupportedMssqlInsights,
-		countEvents: unsupportedMssqlInsights
-	} : adapter.models.insights;
-	return Object.assign(createDatabasePlugin({
-		name: "prisma",
-		models: {
-			...adapter.models,
-			insights
-		},
-		commit: adapter.commit
-	}), {
-		adapterName: "prisma",
-		provider: config.provider,
-		generateSchema: ((version) => ({
-			code: generatePrismaSchema(config.provider, version === "latest" ? hotUpdaterSchema : getHotUpdaterSchemaVersion(version)),
-			path: "./prisma/schema/hot_updater.prisma"
-		}))
-	});
 };
 //#endregion
 export { prismaAdapter };

package/dist/adapters/prismaExecutor.cjs

@@ -0,0 +1,63 @@
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+//#region src/adapters/prismaExecutor.ts
+/**
+* Prisma reports a raw query's database error as P2010 with the database's
+* code in `meta.code`, and a failed transaction as P2034. The error thrown on
+* carries that code, as the SQL core classifies it, with Prisma's as `cause`.
+*/
+const withDatabaseCode = (dialect, error) => {
+	const { code, meta } = error ?? {};
+	const database = code === "P2034" ? "40001" : meta?.code === void 0 ? void 0 : String(meta.code);
+	if (database === void 0) return error;
+	return Object.assign(new Error(String(meta?.message ?? error.message), { cause: error }), { code: dialect === "sqlite" ? `SQLITE:${database}` : database });
+};
+/** MySQL's ASCII keys are `VarBinary` in Prisma's schema, and read back as bytes. */
+const decoder = new TextDecoder();
+const decodeRow = (row) => {
+	for (const [column, value] of Object.entries(row)) if (value instanceof Uint8Array) row[column] = decoder.decode(value);
+	return row;
+};
+const over = (dialect, client) => ({ async execute({ sql, params }) {
+	try {
+		if (/^\s*SELECT\b/iu.test(sql)) return {
+			rows: (await client.$queryRawUnsafe(sql, ...params)).map(decodeRow),
+			changes: 0
+		};
+		return {
+			rows: [],
+			changes: Number(await client.$executeRawUnsafe(sql, ...params))
+		};
+	} catch (error) {
+		throw withDatabaseCode(dialect, error);
+	}
+} });
+/** Taking the write lock first makes a SQLite transaction behave as BEGIN IMMEDIATE. */
+const writeLock = (dialect) => `UPDATE ${(0, _hot_updater_plugin_core.quoteSql)(dialect, _hot_updater_plugin_core.SETTINGS_TABLE.name)} SET ${(0, _hot_updater_plugin_core.quoteSql)(dialect, "_v")} = ${(0, _hot_updater_plugin_core.quoteSql)(dialect, "_v")} WHERE 0 = 1`;
+/**
+* The SQL core's executor over a Prisma client, through raw queries and
+* interactive transactions. A SQLite transaction takes the write lock with
+* its first statement, as BEGIN IMMEDIATE would.
+*/
+const prismaExecutor = (client, dialect) => ({
+	dialect,
+	...over(dialect, client),
+	async transaction(fn) {
+		try {
+			return await client.$transaction(async (tx) => {
+				const connection = over(dialect, tx);
+				if (dialect === "sqlite") await connection.execute({
+					sql: writeLock(dialect),
+					params: []
+				});
+				return fn(connection);
+			}, {
+				maxWait: 1e4,
+				timeout: 3e4
+			});
+		} catch (error) {
+			throw withDatabaseCode(dialect, error);
+		}
+	}
+});
+//#endregion
+exports.prismaExecutor = prismaExecutor;

package/dist/adapters/prismaExecutor.mjs

@@ -0,0 +1,63 @@
+import { SETTINGS_TABLE, quoteSql } from "@hot-updater/plugin-core";
+//#region src/adapters/prismaExecutor.ts
+/**
+* Prisma reports a raw query's database error as P2010 with the database's
+* code in `meta.code`, and a failed transaction as P2034. The error thrown on
+* carries that code, as the SQL core classifies it, with Prisma's as `cause`.
+*/
+const withDatabaseCode = (dialect, error) => {
+	const { code, meta } = error ?? {};
+	const database = code === "P2034" ? "40001" : meta?.code === void 0 ? void 0 : String(meta.code);
+	if (database === void 0) return error;
+	return Object.assign(new Error(String(meta?.message ?? error.message), { cause: error }), { code: dialect === "sqlite" ? `SQLITE:${database}` : database });
+};
+/** MySQL's ASCII keys are `VarBinary` in Prisma's schema, and read back as bytes. */
+const decoder = new TextDecoder();
+const decodeRow = (row) => {
+	for (const [column, value] of Object.entries(row)) if (value instanceof Uint8Array) row[column] = decoder.decode(value);
+	return row;
+};
+const over = (dialect, client) => ({ async execute({ sql, params }) {
+	try {
+		if (/^\s*SELECT\b/iu.test(sql)) return {
+			rows: (await client.$queryRawUnsafe(sql, ...params)).map(decodeRow),
+			changes: 0
+		};
+		return {
+			rows: [],
+			changes: Number(await client.$executeRawUnsafe(sql, ...params))
+		};
+	} catch (error) {
+		throw withDatabaseCode(dialect, error);
+	}
+} });
+/** Taking the write lock first makes a SQLite transaction behave as BEGIN IMMEDIATE. */
+const writeLock = (dialect) => `UPDATE ${quoteSql(dialect, SETTINGS_TABLE.name)} SET ${quoteSql(dialect, "_v")} = ${quoteSql(dialect, "_v")} WHERE 0 = 1`;
+/**
+* The SQL core's executor over a Prisma client, through raw queries and
+* interactive transactions. A SQLite transaction takes the write lock with
+* its first statement, as BEGIN IMMEDIATE would.
+*/
+const prismaExecutor = (client, dialect) => ({
+	dialect,
+	...over(dialect, client),
+	async transaction(fn) {
+		try {
+			return await client.$transaction(async (tx) => {
+				const connection = over(dialect, tx);
+				if (dialect === "sqlite") await connection.execute({
+					sql: writeLock(dialect),
+					params: []
+				});
+				return fn(connection);
+			}, {
+				maxWait: 1e4,
+				timeout: 3e4
+			});
+		} catch (error) {
+			throw withDatabaseCode(dialect, error);
+		}
+	}
+});
+//#endregion
+export { prismaExecutor };

package/dist/adapters/sqlProviders.cjs

@@ -0,0 +1,14 @@
+//#region src/adapters/sqlProviders.ts
+/** The dialects Hot Updater's SQL core runs on. */
+const sqlProviders = [
+	"sqlite",
+	"mysql",
+	"postgresql"
+];
+/** The provider an adapter was given, when Hot Updater's SQL core runs on it. */
+const checkSqlProvider = (adapter, provider) => {
+	if (!sqlProviders.includes(provider)) throw new Error(`${adapter}: provider "${String(provider)}" is not supported. Use ${sqlProviders.map((name) => `"${name}"`).join(", ")}; CockroachDB and SQL Server were dropped in 1.0.`);
+	return provider;
+};
+//#endregion
+exports.checkSqlProvider = checkSqlProvider;

package/dist/adapters/sqlProviders.mjs

@@ -0,0 +1,14 @@
+//#region src/adapters/sqlProviders.ts
+/** The dialects Hot Updater's SQL core runs on. */
+const sqlProviders = [
+	"sqlite",
+	"mysql",
+	"postgresql"
+];
+/** The provider an adapter was given, when Hot Updater's SQL core runs on it. */
+const checkSqlProvider = (adapter, provider) => {
+	if (!sqlProviders.includes(provider)) throw new Error(`${adapter}: provider "${String(provider)}" is not supported. Use ${sqlProviders.map((name) => `"${name}"`).join(", ")}; CockroachDB and SQL Server were dropped in 1.0.`);
+	return provider;
+};
+//#endregion
+export { checkSqlProvider };

package/dist/assembly/assemblePlugins.cjs

@@ -0,0 +1,144 @@
+const require_reads = require("../core/reads.cjs");
+const require_api = require("../core/api.cjs");
+const require_official = require("../plugins/official.cjs");
+const require_clientPlugins = require("./clientPlugins.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+//#region src/assembly/assemblePlugins.ts
+const PLUGIN_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"provides",
+	"schemaVersion",
+	"schema",
+	"namespace",
+	"init",
+	"cli"
+]);
+const CLI_KEYS = /* @__PURE__ */ new Set(["clientCredential", "clientPlugin"]);
+const INSTANCE_KEYS = /* @__PURE__ */ new Set([
+	"api",
+	"endpoints",
+	"clientAuth"
+]);
+const METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+]);
+/** An id that prefixes table names is a SQL name; one that does not may use camelCase. */
+const PREFIX_ID = /^[a-z][a-z0-9_]*$/u;
+const UNPREFIXED_ID = /^[a-z][A-Za-z0-9_]*$/u;
+const PATH = /^(\/(:?[A-Za-z0-9_.~-]+))+$/u;
+const fail = (message) => {
+	throw new _hot_updater_plugin_core.HotUpdaterConfigError(message);
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const checkPlugin = (value, at) => {
+	if (!isRecord(value)) return fail(`${at} is not a plugin.`);
+	if ("kind" in value) fail(`${at} has a kind; core is built in and is never passed as a plugin.`);
+	const unknown = Object.keys(value).find((key) => !PLUGIN_KEYS.has(key));
+	if (unknown !== void 0) fail(`${at} has an unknown key "${unknown}".`);
+	const plugin = value;
+	if (plugin.namespace !== void 0 && plugin.namespace !== false) fail(`${at} may only set namespace: false.`);
+	const pattern = plugin.namespace === false ? UNPREFIXED_ID : PREFIX_ID;
+	if (typeof plugin.id !== "string" || !pattern.test(plugin.id)) fail(`${at} needs an id matching ${pattern.source}.`);
+	if (plugin.id === "core") fail(`${at} uses the id "core", which is core's own.`);
+	require_official.checkReservedId(value, at);
+	if (typeof plugin.schemaVersion !== "string" || !isRecord(plugin.schema) || typeof plugin.init !== "function") fail(`Plugin "${plugin.id}" needs a schemaVersion, a schema, and init.`);
+	const provides = plugin.provides;
+	if (provides !== void 0 && (!isRecord(provides) || Object.entries(provides).some(([key, flag]) => key !== "clientAuth" || flag !== true))) fail(`Plugin "${plugin.id}" may only declare provides: { clientAuth: true }.`);
+	const cli = value.cli;
+	if (cli !== void 0) {
+		if (!isRecord(cli) || Object.keys(cli).some((key) => !CLI_KEYS.has(key))) fail(`Plugin "${plugin.id}" cli may only hold clientCredential and clientPlugin.`);
+		if (cli.clientCredential !== void 0 && plugin.provides?.clientAuth !== true) fail(`Plugin "${plugin.id}" adds cli.clientCredential without declaring provides: { clientAuth: true }.`);
+	}
+	return plugin;
+};
+const checkEndpoint = (id, value) => {
+	const endpoint = isRecord(value) ? value : {};
+	if (!METHODS.has(endpoint.method) || typeof endpoint.path !== "string" || !PATH.test(endpoint.path) || endpoint.access !== "client" && endpoint.access !== "admin" || typeof endpoint.handler !== "function") fail(`Plugin "${id}" has an endpoint that needs a method, a path like /name/:param, access "client" or "admin", and a handler.`);
+	return {
+		...endpoint,
+		plugin: id
+	};
+};
+const checkInstance = (plugin, instance) => {
+	const { id } = plugin;
+	if (!isRecord(instance)) return fail(`Plugin "${id}" init returned no instance.`);
+	if (typeof instance.then === "function") fail(`Plugin "${id}" init returned a promise; init must be synchronous.`);
+	const unknown = Object.keys(instance).find((key) => !INSTANCE_KEYS.has(key));
+	if (unknown !== void 0 || !("api" in instance)) fail(`Plugin "${id}" init must return { api, endpoints?, clientAuth? }${unknown === void 0 ? "" : `, not "${unknown}"`}.`);
+	const declared = plugin.provides?.clientAuth === true;
+	const clientAuth = instance.clientAuth;
+	if (declared !== (clientAuth !== void 0)) fail(declared ? `Plugin "${id}" declares provides: { clientAuth: true } but its instance has no clientAuth.` : `Plugin "${id}" returns clientAuth without declaring provides: { clientAuth: true }.`);
+	if (clientAuth !== void 0 && (typeof clientAuth.authenticate !== "function" || !Array.isArray(clientAuth.varyHeaders) || !clientAuth.varyHeaders.every((header) => typeof header === "string"))) fail(`Plugin "${id}" clientAuth needs varyHeaders and authenticate.`);
+	const endpoints = instance.endpoints ?? [];
+	if (!Array.isArray(endpoints)) fail(`Plugin "${id}" endpoints must be an array.`);
+	return {
+		api: instance.api,
+		clientAuth,
+		endpoints: endpoints.map((endpoint) => checkEndpoint(id, endpoint))
+	};
+};
+/**
+* Checks every plugin, runs each `init` once against one engine over the
+* database, and collects APIs, endpoints, and clientAuth. Core's reads run
+* on the same engine, so plugins read core through `ctx.core`.
+*/
+const assemblePlugins = (value, database, { now = Date.now, storage = { resolveFileUrl: async () => null } } = {}) => {
+	if (!Array.isArray(value)) return fail("plugins must be an array of plugins.");
+	const plugins = value.map((plugin, position) => checkPlugin(plugin, `plugins[${position}]`));
+	const ids = /* @__PURE__ */ new Set();
+	for (const { id } of plugins) {
+		if (ids.has(id)) fail(`Plugin "${id}" is registered twice.`);
+		ids.add(id);
+	}
+	require_clientPlugins.clientPluginsOf(plugins);
+	const engine = (0, _hot_updater_plugin_core.createEngine)(database, {
+		plugins,
+		now
+	});
+	const { onCachedRoutesChange } = database;
+	const core = require_api.createCoreApi(engine.core, storage, {
+		now,
+		...onCachedRoutesChange === void 0 ? {} : { onCachedRoutesChange: () => onCachedRoutesChange.call(database) }
+	});
+	const reads = require_reads.createCoreReads(engine.core, storage);
+	const api = {};
+	const endpoints = [];
+	let clientAuth;
+	for (const plugin of plugins) {
+		const instance = checkInstance(plugin, plugin.init({
+			db: engine.database(plugin),
+			core: reads,
+			now
+		}));
+		if (instance.clientAuth !== void 0) {
+			if (clientAuth !== void 0) fail(`Plugins "${clientAuth.plugin}" and "${plugin.id}" both provide clientAuth; keep one.`);
+			const provided = instance.clientAuth;
+			clientAuth = {
+				plugin: plugin.id,
+				varyHeaders: provided.varyHeaders,
+				authenticate: (headers) => provided.authenticate(headers)
+			};
+		}
+		endpoints.push(...instance.endpoints);
+		api[plugin.id] = instance.api;
+	}
+	return {
+		core,
+		api,
+		endpoints,
+		...clientAuth === void 0 ? {} : { clientAuth },
+		flush: engine.flush
+	};
+};
+//#endregion
+Object.defineProperty(exports, "HotUpdaterConfigError", {
+	enumerable: true,
+	get: function() {
+		return _hot_updater_plugin_core.HotUpdaterConfigError;
+	}
+});
+exports.assemblePlugins = assemblePlugins;

package/dist/assembly/assemblePlugins.d.cts

@@ -0,0 +1,5 @@
+import "../core/reads.cjs";
+import "../core/api.cjs";
+import "../plugins/definePlugin.cjs";
+import { HotUpdaterConfigError } from "./configError.cjs";
+import "@hot-updater/plugin-core";

package/dist/assembly/assemblePlugins.d.mts

@@ -0,0 +1,5 @@
+import "../core/reads.mjs";
+import "../core/api.mjs";
+import "../plugins/definePlugin.mjs";
+import { HotUpdaterConfigError } from "./configError.mjs";
+import "@hot-updater/plugin-core";