@hot-updater/cloudflare 1.0.0-rc.1 → 1.0.0-rc.16

package/dist/iac/index.cjs

@@ -6,7 +6,7 @@ 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 __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), 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];
@@ -17,35 +17,36 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
 //#endregion
 let crypto = require("crypto");
-crypto = __toESM(crypto);
+crypto = __toESM(crypto, 1);
 let fs_promises = require("fs/promises");
-fs_promises = __toESM(fs_promises);
+fs_promises = __toESM(fs_promises, 1);
 let path = require("path");
-path = __toESM(path);
+path = __toESM(path, 1);
 let _hot_updater_cli_tools = require("@hot-updater/cli-tools");
-let _hot_updater_server = require("@hot-updater/server");
+let _hot_updater_server_db = require("@hot-updater/server/db");
 let cloudflare = require("cloudflare");
-cloudflare = __toESM(cloudflare);
-let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
-let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+cloudflare = __toESM(cloudflare, 1);
+let _hot_updater_server_database = require("@hot-updater/server/database");
+let _hot_updater_server_plugins_api_keys = require("@hot-updater/server/plugins/api-keys");
+let _hot_updater_server_plugins_insights = require("@hot-updater/server/plugins/insights");
 let node_url = require("node:url");
 let node_child_process = require("node:child_process");
 let node_string_decoder = require("node:string_decoder");
 let node_util = require("node:util");
 let node_process = require("node:process");
-node_process = __toESM(node_process);
+node_process = __toESM(node_process, 1);
 let node_tty = require("node:tty");
-node_tty = __toESM(node_tty);
+node_tty = __toESM(node_tty, 1);
 let node_path = require("node:path");
-node_path = __toESM(node_path);
+node_path = __toESM(node_path, 1);
 let fs = require("fs");
-fs = __toESM(fs);
+fs = __toESM(fs, 1);
 let node_timers_promises = require("node:timers/promises");
 let node_os = require("node:os");
 let node_events = require("node:events");
@@ -56,896 +57,118 @@ let node_stream = require("node:stream");
 let node_buffer = require("node:buffer");
 let cloudflare_error = require("cloudflare/error");
 let os = require("os");
-os = __toESM(os);
-//#region src/d1Rows.ts
-var InvalidD1RowError = class extends Error {
-	name = "InvalidD1RowError";
-	model;
-	constructor(model) {
-		super(`D1 returned an invalid ${model} row`);
-		this.model = model;
-	}
-};
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const stringValue = (row, field, model) => {
-	const value = row[field];
-	if (typeof value !== "string") throw new InvalidD1RowError(model);
-	return value;
-};
-const nullableString = (row, field, model) => {
-	const value = row[field];
-	if (value === null) return null;
-	if (typeof value !== "string") throw new InvalidD1RowError(model);
-	return value;
-};
-const numberValue = (row, field, model) => {
-	const value = row[field];
-	if (typeof value !== "number") throw new InvalidD1RowError(model);
-	return value;
-};
-const byteSizeValue = (row, field, model) => {
-	const value = row[field];
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new InvalidD1RowError(model);
-	return value;
-};
-const booleanValue = (row, field, model) => {
-	const value = row[field];
-	if (value === true || value === 1) return true;
-	if (value === false || value === 0) return false;
-	throw new InvalidD1RowError(model);
-};
-const jsonValue = (value, model) => {
-	if (typeof value !== "string") throw new InvalidD1RowError(model);
-	try {
-		return JSON.parse(value);
-	} catch (error) {
-		if (error instanceof SyntaxError) throw new InvalidD1RowError(model);
-		throw error;
-	}
-};
-const metadata = (row) => {
-	const value = jsonValue(row["metadata"], "bundles");
-	if (!(0, _hot_updater_plugin_core.isDatabaseMetadataObject)(value)) throw new InvalidD1RowError("bundles");
-	return value;
-};
-const bundleRow = (row) => {
-	const platform = stringValue(row, "platform", "bundles");
-	if (platform !== "ios" && platform !== "android") throw new InvalidD1RowError("bundles");
-	return {
-		id: stringValue(row, "id", "bundles"),
-		platform,
-		file_hash: stringValue(row, "file_hash", "bundles"),
-		git_commit_hash: nullableString(row, "git_commit_hash", "bundles"),
-		storage_uri: stringValue(row, "storage_uri", "bundles"),
-		archive_byte_size: row["archive_byte_size"] === void 0 ? 0 : byteSizeValue(row, "archive_byte_size", "bundles"),
-		metadata: metadata(row),
-		manifest_storage_uri: nullableString(row, "manifest_storage_uri", "bundles"),
-		manifest_file_hash: nullableString(row, "manifest_file_hash", "bundles"),
-		asset_base_storage_uri: nullableString(row, "asset_base_storage_uri", "bundles")
-	};
-};
-const patchRow = (row) => ({
-	id: stringValue(row, "id", "bundle_patches"),
-	bundle_id: stringValue(row, "bundle_id", "bundle_patches"),
-	base_bundle_id: stringValue(row, "base_bundle_id", "bundle_patches"),
-	base_file_hash: stringValue(row, "base_file_hash", "bundle_patches"),
-	patch_file_hash: stringValue(row, "patch_file_hash", "bundle_patches"),
-	patch_storage_uri: stringValue(row, "patch_storage_uri", "bundle_patches"),
-	byte_size: byteSizeValue(row, "byte_size", "bundle_patches"),
-	order_index: numberValue(row, "order_index", "bundle_patches")
-});
-const channelRow = (row) => ({
-	id: stringValue(row, "id", "channels"),
-	name: stringValue(row, "name", "channels")
-});
-const eventRow = (row) => {
-	const type = stringValue(row, "type", "bundle_events");
-	const platform = stringValue(row, "platform", "bundle_events");
-	const fromBundleId = nullableString(row, "from_bundle_id", "bundle_events");
-	const updateStrategy = nullableString(row, "update_strategy", "bundle_events");
-	if (platform !== "ios" && platform !== "android" || !((type === "UPDATE_APPLIED" || type === "RECOVERED" || type === "RELEASE_ADOPTED") && typeof fromBundleId === "string" && (updateStrategy === "fingerprint" || updateStrategy === "appVersion") || type === "UNCHANGED" && fromBundleId === null && updateStrategy === null)) throw new InvalidD1RowError("bundle_events");
-	return {
-		id: stringValue(row, "id", "bundle_events"),
-		type,
-		install_id: stringValue(row, "install_id", "bundle_events"),
-		user_id: nullableString(row, "user_id", "bundle_events"),
-		username: nullableString(row, "username", "bundle_events"),
-		from_release_id: nullableString(row, "from_release_id", "bundle_events"),
-		from_bundle_id: fromBundleId,
-		to_release_id: nullableString(row, "to_release_id", "bundle_events"),
-		to_bundle_id: stringValue(row, "to_bundle_id", "bundle_events"),
-		platform,
-		app_version: stringValue(row, "app_version", "bundle_events"),
-		channel: stringValue(row, "channel", "bundle_events"),
-		cohort: stringValue(row, "cohort", "bundle_events"),
-		update_strategy: updateStrategy,
-		fingerprint_hash: nullableString(row, "fingerprint_hash", "bundle_events"),
-		sdk_version: nullableString(row, "sdk_version", "bundle_events"),
-		received_at_ms: numberValue(row, "received_at_ms", "bundle_events")
-	};
-};
-const apiKeyRow = (row) => {
-	const role = stringValue(row, "role", "api_keys");
-	if (role !== "client") throw new InvalidD1RowError("api_keys");
-	const revokedAt = row["revoked_at_ms"];
-	return {
-		id: stringValue(row, "id", "api_keys"),
-		hash: stringValue(row, "hash", "api_keys"),
-		name: stringValue(row, "name", "api_keys"),
-		prefix: stringValue(row, "prefix", "api_keys"),
-		role,
-		created_at_ms: numberValue(row, "created_at_ms", "api_keys"),
-		revoked_at_ms: revokedAt === null ? null : numberValue(row, "revoked_at_ms", "api_keys")
-	};
-};
-const releaseTargetCohorts = (row) => {
-	const value = jsonValue(row["target_cohorts"], "releases");
-	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new InvalidD1RowError("releases");
-	return value.filter((item) => typeof item === "string");
-};
-const releaseRow = (row) => {
-	const platform = stringValue(row, "platform", "releases");
-	const kind = stringValue(row, "kind", "releases");
-	const strategy = stringValue(row, "strategy", "releases");
-	const operation = stringValue(row, "operation", "releases");
-	if (platform !== "ios" && platform !== "android" || kind !== "BUNDLE" && kind !== "EMBEDDED" || strategy !== "APP_VERSION" && strategy !== "FINGERPRINT" || operation !== "DEPLOY" && operation !== "PROMOTE" && operation !== "ROLLBACK") throw new InvalidD1RowError("releases");
-	return {
-		id: stringValue(row, "id", "releases"),
-		revision: numberValue(row, "revision", "releases"),
-		scope_key: stringValue(row, "scope_key", "releases"),
-		channel_id: stringValue(row, "channel_id", "releases"),
-		platform,
-		kind,
-		bundle_id: nullableString(row, "bundle_id", "releases"),
-		strategy,
-		target_app_version: nullableString(row, "target_app_version", "releases"),
-		fingerprint_hash: nullableString(row, "fingerprint_hash", "releases"),
-		enabled: booleanValue(row, "enabled", "releases"),
-		should_force_update: booleanValue(row, "should_force_update", "releases"),
-		message: nullableString(row, "message", "releases"),
-		rollout_cohort_count: numberValue(row, "rollout_cohort_count", "releases"),
-		target_cohorts: releaseTargetCohorts(row),
-		operation,
-		source_release_id: nullableString(row, "source_release_id", "releases"),
-		created_at_ms: numberValue(row, "created_at_ms", "releases"),
-		updated_at_ms: numberValue(row, "updated_at_ms", "releases")
-	};
-};
-const releaseCatalogRow = (row) => {
-	const platform = stringValue(row, "platform", "release_catalogs");
-	const strategy = stringValue(row, "strategy", "release_catalogs");
-	if (platform !== "ios" && platform !== "android" || strategy !== "APP_VERSION" && strategy !== "FINGERPRINT") throw new InvalidD1RowError("release_catalogs");
-	return {
-		scope_key: stringValue(row, "scope_key", "release_catalogs"),
-		catalog_id: stringValue(row, "catalog_id", "release_catalogs"),
-		strategy,
-		channel_id: stringValue(row, "channel_id", "release_catalogs"),
-		channel_key: stringValue(row, "channel_key", "release_catalogs"),
-		platform,
-		fingerprint_hash: nullableString(row, "fingerprint_hash", "release_catalogs"),
-		generation: numberValue(row, "generation", "release_catalogs"),
-		payload: stringValue(row, "payload", "release_catalogs"),
-		catalog_hash: stringValue(row, "catalog_hash", "release_catalogs"),
-		byte_size: numberValue(row, "byte_size", "release_catalogs"),
-		is_tombstone: booleanValue(row, "is_tombstone", "release_catalogs"),
-		updated_at_ms: numberValue(row, "updated_at_ms", "release_catalogs")
-	};
-};
-function parseD1Row(model, value) {
-	if (!isRecord(value)) throw new InvalidD1RowError(model);
-	switch (model) {
-		case "bundles": return bundleRow(value);
-		case "bundle_patches": return patchRow(value);
-		case "channels": return channelRow(value);
-		case "bundle_events": return eventRow(value);
-		case "api_keys": return apiKeyRow(value);
-		case "releases": return releaseRow(value);
-		case "release_catalogs": return releaseCatalogRow(value);
-	}
-}
-//#endregion
-//#region src/d1Sql.ts
-var InvalidD1PredicateError = class extends Error {
-	name = "InvalidD1PredicateError";
-};
-const encodeD1Value = (value) => {
-	const encoded = JSON.stringify(value);
-	if (encoded === void 0) throw new TypeError("D1 values must be JSON-serializable.");
-	return encoded;
-};
-const bind = (value) => ({
-	sql: "json_extract(?, '$')",
-	params: [encodeD1Value(value)]
-});
-const escapeLikePattern = (value) => value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
-const stringPredicate = (condition, operator) => {
-	if (typeof condition.value !== "string") throw new InvalidD1PredicateError();
-	if (condition.mode !== "insensitive") {
-		const parameter = bind(condition.value);
-		const column = `${condition.field} COLLATE BINARY`;
-		const value = `${parameter.sql} COLLATE BINARY`;
-		if (operator === "contains" || operator === "starts_with") return {
-			sql: `instr(${column}, ${value}) ${operator === "contains" ? "> 0" : "= 1"}`,
-			params: parameter.params
-		};
-		return {
-			sql: `substr(${column}, length(${condition.field}) - length(${parameter.sql}) + 1) = ${value}`,
-			params: [...parameter.params, ...parameter.params]
-		};
-	}
-	const literal = escapeLikePattern(condition.value);
-	const parameter = bind(operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`);
-	return {
-		sql: `lower(${condition.field}) LIKE lower(${parameter.sql}) ESCAPE '\\'`,
-		params: parameter.params
-	};
-};
-const predicate = (condition) => {
-	const operator = condition.operator ?? "eq";
-	switch (operator) {
-		case "eq":
-		case "ne": {
-			if (condition.value === null) return {
-				sql: `${condition.field} IS ${operator === "ne" ? "NOT " : ""}NULL`,
-				params: []
-			};
-			const parameter = bind(condition.value);
-			const insensitive = "mode" in condition && condition.mode === "insensitive";
-			const column = insensitive ? `lower(${condition.field})` : condition.field;
-			const value = insensitive ? `lower(${parameter.sql})` : parameter.sql;
-			return {
-				sql: `${column} ${operator === "eq" ? "=" : "<>"} ${value}`,
-				params: parameter.params
-			};
-		}
-		case "gt":
-		case "gte":
-		case "lt":
-		case "lte": {
-			const sqlOperator = {
-				gt: ">",
-				gte: ">=",
-				lt: "<",
-				lte: "<="
-			}[operator];
-			const parameter = bind(condition.value);
-			return {
-				sql: `${condition.field} ${sqlOperator} ${parameter.sql}`,
-				params: parameter.params
-			};
-		}
-		case "in":
-		case "not_in":
-			if (!Array.isArray(condition.value)) throw new InvalidD1PredicateError();
-			if (condition.value.length === 0) return {
-				sql: operator === "not_in" ? "1 = 1" : "1 = 0",
-				params: []
-			};
-			return {
-				sql: `${condition.field} ${operator === "not_in" ? "NOT " : ""}IN (SELECT value FROM json_each(?))`,
-				params: [encodeD1Value(condition.value)]
-			};
-		case "contains":
-		case "starts_with":
-		case "ends_with": return stringPredicate(condition, operator);
+os = __toESM(os, 1);
+//#region src/d1Executor.ts
+var D1ExecutionError = class extends Error {
+	name = "D1ExecutionError";
+	constructor() {
+		super("D1 did not successfully execute every requested statement");
 	}
 };
-const buildD1Where = (where) => {
-	const [first, ...rest] = where ?? [];
-	if (first === void 0) return {
-		sql: "",
-		params: []
-	};
-	const initial = predicate(first);
-	let sql = initial.sql;
-	const params = [...initial.params];
-	for (const condition of rest) {
-		const next = predicate(condition);
-		sql = `(${sql} ${condition.connector === "OR" ? "OR" : "AND"} ${next.sql})`;
-		params.push(...next.params);
-	}
+const toSqlResult = (result) => {
+	if (result.success === false) throw new D1ExecutionError();
 	return {
-		sql: ` WHERE ${sql}`,
-		params
+		rows: result.results ?? [],
+		changes: result.meta?.changes ?? 0
 	};
 };
-const buildD1Order = (orderBy) => orderBy === void 0 ? "" : ` ORDER BY ${orderBy.map((clause) => `${clause.field} ${clause.direction.toUpperCase()}${clause.nulls ? ` NULLS ${clause.nulls.toUpperCase()}` : ""}`).join(", ")}`;
-const d1Placeholders = (count) => Array.from({ length: count }, () => "json_extract(?, '$')").join(", ");
-const encodeD1Values = (values) => values.map(encodeD1Value);
-//#endregion
-//#region src/d1Query.ts
-const d1TableNames = {
-	bundles: "bundles",
-	bundle_patches: "bundle_patches",
-	channels: "channels",
-	bundle_events: "bundle_events",
-	api_keys: "api_keys",
-	release_catalogs: "release_catalogs",
-	releases: "releases"
-};
-var D1QueryResultError = class extends Error {
-	name = "D1QueryResultError";
-	operation = "count";
-	constructor(result) {
-		super("D1 count query returned a malformed first row");
-		this.result = result;
-	}
-};
-const countD1Rows = async (executor, input) => {
-	const where = buildD1Where(input.where);
-	const table = d1TableNames[input.model];
-	const source = input.distinct === void 0 ? `${table}${where.sql}` : `(SELECT DISTINCT ${input.distinct.join(", ")} FROM ${table}${where.sql}) AS distinct_rows`;
-	const row = (await executor.query(`SELECT COUNT(*) AS count FROM ${source}`, where.params))[0];
-	if (typeof row !== "object" || row === null || Array.isArray(row)) throw new D1QueryResultError(row);
-	const count = Reflect.get(row, "count");
-	if (typeof count !== "number" || !Number.isFinite(count)) throw new D1QueryResultError(row);
-	return count;
-};
-const findManyD1Rows = async (executor, input) => {
-	const where = buildD1Where(input.where);
-	const orderBy = input.orderBy;
-	const order = buildD1Order(orderBy);
-	const table = d1TableNames[input.model];
-	const source = input.distinctOn === void 0 ? `SELECT * FROM ${table}${where.sql}${order}` : `SELECT * FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY ${input.distinctOn.fields.join(", ")}${order}) AS __hot_updater_rank FROM ${table}${where.sql}) AS distinct_rows WHERE __hot_updater_rank = 1${order}`;
-	const pageParams = encodeD1Values([input.limit, input.offset]);
-	const rows = await executor.query(`${source} LIMIT json_extract(?, '$') OFFSET json_extract(?, '$')`, [...where.params, ...pageParams]);
-	switch (input.model) {
-		case "bundles": return rows.map((row) => parseD1Row("bundles", row));
-		case "bundle_patches": return rows.map((row) => parseD1Row("bundle_patches", row));
-		case "channels": return rows.map((row) => parseD1Row("channels", row));
-		case "bundle_events": return rows.map((row) => parseD1Row("bundle_events", row));
-		case "api_keys": return rows.map((row) => parseD1Row("api_keys", row));
-		case "releases": return rows.map((row) => parseD1Row("releases", row));
-		case "release_catalogs": return rows.map((row) => parseD1Row("release_catalogs", row));
-	}
-};
-//#endregion
-//#region src/d1Implementation.ts
-const EXPECTATION_CONFLICT_MARKER = "HOT_UPDATER_COMMIT_EXPECTATION_CONFLICT";
-const expectationGuard = (expectations) => {
-	const clauses = [];
-	const params = [];
-	for (const expectation of expectations) {
-		const isRelease = expectation.model === "releases";
-		const table = isRelease ? "releases" : "release_catalogs";
-		const keyField = isRelease ? "id" : "scope_key";
-		const versionField = isRelease ? "revision" : "generation";
-		const key = isRelease ? expectation.id : expectation.scopeKey;
-		const version = isRelease ? expectation.revision : expectation.generation;
-		if (version === null) {
-			clauses.push(`NOT EXISTS (SELECT 1 FROM ${table} WHERE ${keyField} = json_extract(?, '$'))`);
-			params.push(...encodeD1Values([key]));
-		} else {
-			clauses.push(`EXISTS (SELECT 1 FROM ${table} WHERE ${keyField} = json_extract(?, '$') AND ${versionField} = json_extract(?, '$'))`);
-			params.push(...encodeD1Values([key, version]));
-		}
-	}
-	return {
-		sql: clauses.join(" AND ") || "1",
-		params
-	};
-};
-const readVersion = (row, field) => {
-	if (typeof row !== "object" || row === null) return null;
-	const value = Reflect.get(row, field);
-	return typeof value === "number" ? value : null;
-};
-const expectationConflict = async (executor, expectations) => {
-	for (const expectation of expectations) {
-		const isRelease = expectation.model === "releases";
-		const table = isRelease ? "releases" : "release_catalogs";
-		const keyField = isRelease ? "id" : "scope_key";
-		const versionField = isRelease ? "revision" : "generation";
-		const key = isRelease ? expectation.id : expectation.scopeKey;
-		const expectedVersion = isRelease ? expectation.revision : expectation.generation;
-		const actualVersion = readVersion((await executor.query(`SELECT ${versionField} FROM ${table} WHERE ${keyField} = json_extract(?, '$') LIMIT 1`, encodeD1Values([key])))[0], versionField);
-		if (actualVersion !== expectedVersion) return {
-			committed: false,
-			conflict: {
-				actualVersion,
-				changeIndex: -1,
-				expectedVersion,
-				key,
-				model: expectation.model,
-				reason: "version_conflict"
-			}
-		};
-	}
-	return null;
-};
-const isExpectationConflictError = (error) => {
+/** D1 reports SQLite errors in the message; the SQL core classifies codes. */
+const withSqliteCode = (error) => {
 	const message = error instanceof Error ? error.message : String(error);
-	return message.includes(EXPECTATION_CONFLICT_MARKER) || message.toLowerCase().includes("malformed json");
-};
-const bundleValues = (row) => [
-	row.id,
-	row.platform,
-	row.file_hash,
-	row.git_commit_hash,
-	row.storage_uri,
-	row.archive_byte_size,
-	row.metadata,
-	row.manifest_storage_uri,
-	row.manifest_file_hash,
-	row.asset_base_storage_uri
-];
-const patchValues = (row) => [
-	row.id,
-	row.bundle_id,
-	row.base_bundle_id,
-	row.base_file_hash,
-	row.patch_file_hash,
-	row.patch_storage_uri,
-	row.byte_size,
-	row.order_index
-];
-const channelValues = (row) => [row.id, row.name];
-const insertQuery = (input, guard, conflictMode = "returnExisting") => {
-	let columns;
-	let values;
-	switch (input.model) {
-		case "bundles":
-			columns = [
-				"id",
-				"platform",
-				"file_hash",
-				"git_commit_hash",
-				"storage_uri",
-				"archive_byte_size",
-				"metadata",
-				"manifest_storage_uri",
-				"manifest_file_hash",
-				"asset_base_storage_uri"
-			];
-			values = bundleValues(input.data);
-			break;
-		case "bundle_patches":
-			columns = [
-				"id",
-				"bundle_id",
-				"base_bundle_id",
-				"base_file_hash",
-				"patch_file_hash",
-				"patch_storage_uri",
-				"byte_size",
-				"order_index"
-			];
-			values = patchValues(input.data);
-			break;
-		case "channels":
-			columns = ["id", "name"];
-			values = channelValues(input.data);
-			break;
-		case "bundle_events":
-		case "api_keys":
-		case "release_catalogs":
-		case "releases":
-			columns = Object.keys(input.data);
-			values = Object.values(input.data);
-			break;
-	}
-	const conflict = input.onConflict !== "ignore" ? "" : input.model === "channels" ? conflictMode === "ignore" ? " ON CONFLICT(name) DO NOTHING" : " ON CONFLICT(name) DO UPDATE SET name = excluded.name" : input.model === "api_keys" ? conflictMode === "ignore" ? " ON CONFLICT(hash) DO NOTHING" : " ON CONFLICT(hash) DO UPDATE SET hash = excluded.hash" : "";
-	return {
-		sql: `INSERT INTO ${d1TableNames[input.model]} (${columns.join(", ")}) ${guard === void 0 ? `VALUES (${d1Placeholders(values.length)})` : `SELECT ${d1Placeholders(values.length)} WHERE ${guard.sql}`}${conflict} RETURNING *`,
-		params: [...encodeD1Values(values), ...guard?.params ?? []]
-	};
-};
-const updateEntries = (update) => Object.entries(update);
-const updateQuery = (input, guard) => {
-	const entries = updateEntries(input.update);
-	const where = buildD1Where(input.where);
-	if (entries.length === 0) return {
-		sql: `SELECT * FROM ${d1TableNames[input.model]}${where.sql}${guard ? ` AND ${guard.sql}` : ""} LIMIT 1`,
-		params: [...where.params, ...guard?.params ?? []]
-	};
-	const assignments = entries.map(([field]) => `${field} = json_extract(?, '$')`).join(", ");
-	return {
-		sql: `UPDATE ${d1TableNames[input.model]} SET ${assignments}${where.sql}${guard ? ` AND ${guard.sql}` : ""} RETURNING *`,
-		params: [
-			...encodeD1Values(entries.map(([, value]) => value)),
-			...where.params,
-			...guard?.params ?? []
-		]
-	};
-};
-const deleteQuery = (input, guard) => {
-	const where = buildD1Where(input.where);
-	return {
-		sql: `DELETE FROM ${d1TableNames[input.model]}${where.sql}${guard ? ` AND ${guard.sql}` : ""}`,
-		params: [...where.params, ...guard?.params ?? []]
-	};
-};
-const insertedKey = (change) => {
-	if (change.operation !== "insert") return void 0;
-	if (change.model === "bundles") return `bundles:${change.row.id}`;
-	if (change.model === "apiKeys") return `api_keys:${change.row.id}`;
-	if (change.model === "releases") return `releases:${change.row.id}`;
-};
-const requiredRow = (change, changeIndex) => {
-	if (change.operation !== "update") return void 0;
-	if (change.model === "bundles") return {
-		model: "bundles",
-		id: change.where.id,
-		changeIndex
-	};
-	if (change.model === "apiKeys") return {
-		model: "api_keys",
-		id: change.where.id,
-		changeIndex
-	};
-	if (change.model === "releases") return {
-		model: "releases",
-		id: change.where.id,
-		changeIndex
-	};
-};
-const channelDeletePrecondition = (changes, changeIndex, channelId) => {
-	const releaseEffects = /* @__PURE__ */ new Map();
-	for (const change of changes.slice(0, changeIndex)) {
-		if (change.model !== "releases") continue;
-		switch (change.operation) {
-			case "insert":
-				releaseEffects.set(change.row.id, change.row.channel_id);
-				break;
-			case "update": break;
-			case "delete":
-				releaseEffects.set(change.where.id, null);
-				break;
-		}
-	}
-	return {
-		id: channelId,
-		excludedReleaseIds: [...releaseEffects.keys()],
-		addedReferenceReleaseIds: [...releaseEffects].filter(([, finalChannelId]) => finalChannelId === channelId).map(([releaseId]) => releaseId)
-	};
-};
-const changeQuery = (change, guard) => {
-	switch (change.model) {
-		case "bundles": switch (change.operation) {
-			case "insert": return insertQuery({
-				model: "bundles",
-				data: change.row
-			}, guard);
-			case "update": return updateQuery({
-				model: "bundles",
-				where: [{
-					field: "id",
-					value: change.where.id
-				}],
-				update: change.update
-			}, guard);
-			case "delete": return deleteQuery({
-				model: "bundles",
-				where: [{
-					field: "id",
-					value: change.where.id
-				}]
-			}, guard);
-		}
-		case "bundlePatches": return change.operation === "insert" ? insertQuery({
-			model: "bundle_patches",
-			data: change.row
-		}, guard) : deleteQuery({
-			model: "bundle_patches",
-			where: [{
-				field: "bundle_id",
-				value: change.where.bundleId
-			}]
-		}, guard);
-		case "releases": switch (change.operation) {
-			case "insert": return insertQuery({
-				model: "releases",
-				data: change.row
-			}, guard);
-			case "update": return updateQuery({
-				model: "releases",
-				where: [{
-					field: "id",
-					value: change.where.id
-				}],
-				update: change.update
-			}, guard);
-			case "delete": return deleteQuery({
-				model: "releases",
-				where: [{
-					field: "id",
-					value: change.where.id
-				}]
-			}, guard);
-		}
-		case "releaseCatalogs": return {
-			sql: `INSERT INTO release_catalogs (${Object.keys(change.row).join(", ")}) SELECT ${d1Placeholders(Object.keys(change.row).length)} WHERE ${guard.sql} ON CONFLICT(scope_key) DO UPDATE SET ${Object.keys(change.row).filter((field) => field !== "scope_key").map((field) => `${field} = excluded.${field}`).join(", ")} RETURNING *`,
-			params: [...encodeD1Values(Object.values(change.row)), ...guard.params]
-		};
-		case "channels": return change.operation === "insert" ? insertQuery({
-			model: "channels",
-			data: change.row,
-			onConflict: change.onConflict
-		}, guard, "ignore") : {
-			sql: `DELETE FROM channels WHERE id = json_extract(?, '$') AND NOT EXISTS (SELECT 1 FROM releases WHERE channel_id = json_extract(?, '$')) AND ${guard.sql}`,
-			params: [...encodeD1Values([change.where.id, change.where.id]), ...guard.params]
-		};
-		case "analytics": return insertQuery({
-			model: "bundle_events",
-			data: change.row
-		}, guard);
-		case "apiKeys": return change.operation === "insert" ? insertQuery({
-			model: "api_keys",
-			data: change.row,
-			onConflict: change.onConflict
-		}, guard, "ignore") : updateQuery({
-			model: "api_keys",
-			where: [{
-				field: "id",
-				value: change.where.id
-			}],
-			update: { revoked_at_ms: change.update.revokedAtMs }
-		}, guard);
-	}
-};
-const createCommitPlan = (input) => {
-	const checks = [];
-	const statements = [];
-	const expectations = input.expectations ?? [];
-	if (expectations.length > 0) {
-		const guard = expectationGuard(expectations);
-		statements.push({
-			sql: `SELECT CASE WHEN ${guard.sql} THEN 1 ELSE json_extract('${EXPECTATION_CONFLICT_MARKER}', '$') END AS expectation_guard`,
-			params: guard.params
-		});
-	}
-	const requiredRows = [];
-	const channelDeletes = [];
-	const inserted = /* @__PURE__ */ new Set();
-	for (const [changeIndex, change] of input.changes.entries()) {
-		const required = requiredRow(change, changeIndex);
-		if (required !== void 0) {
-			if (!inserted.has(`${required.model}:${required.id}`)) {
-				requiredRows.push(required);
-				checks.push({
-					changeIndex,
-					resultIndex: statements.length,
-					conflictWhen: "empty",
-					reason: "not_found"
-				});
-				statements.push({
-					sql: `SELECT id FROM ${d1TableNames[required.model]} WHERE id = json_extract(?, '$') LIMIT 1`,
-					params: encodeD1Values([required.id])
-				});
-			}
-		}
-		if (change.model === "channels" && change.operation === "delete") {
-			const precondition = channelDeletePrecondition(input.changes, changeIndex, change.where.id);
-			channelDeletes.push(precondition);
-			checks.push({
-				changeIndex,
-				resultIndex: statements.length,
-				conflictWhen: "nonempty",
-				reason: "referenced"
-			});
-			statements.push({
-				sql: "SELECT id FROM releases WHERE channel_id = json_extract(?, '$') AND id NOT IN (SELECT value FROM json_each(?)) UNION ALL SELECT value AS id FROM json_each(?) LIMIT 1",
-				params: encodeD1Values([
-					precondition.id,
-					precondition.excludedReleaseIds,
-					precondition.addedReferenceReleaseIds
-				])
-			});
-		}
-		const key = insertedKey(change);
-		if (key !== void 0) inserted.add(key);
-	}
-	const guard = {
-		sql: `NOT EXISTS (
-      SELECT 1 FROM json_each(?) AS required
-      WHERE NOT EXISTS (
-        SELECT 1 FROM bundles
-        WHERE json_extract(required.value, '$.model') = 'bundles'
-          AND bundles.id = json_extract(required.value, '$.id')
-        UNION ALL
-        SELECT 1 FROM api_keys
-        WHERE json_extract(required.value, '$.model') = 'api_keys'
-          AND api_keys.id = json_extract(required.value, '$.id')
-        UNION ALL
-        SELECT 1 FROM channels
-        WHERE json_extract(required.value, '$.model') = 'channels'
-          AND channels.id = json_extract(required.value, '$.id')
-        UNION ALL
-        SELECT 1 FROM releases
-        WHERE json_extract(required.value, '$.model') = 'releases'
-          AND releases.id = json_extract(required.value, '$.id')
-      )
-    ) AND NOT EXISTS (
-      SELECT 1 FROM json_each(?) AS channel_delete
-      WHERE EXISTS (
-        SELECT 1 FROM releases
-        WHERE releases.channel_id = json_extract(channel_delete.value, '$.id')
-          AND releases.id NOT IN (
-            SELECT value FROM json_each(
-              json_extract(channel_delete.value, '$.excludedReleaseIds')
-            )
-          )
-        UNION ALL
-        SELECT value FROM json_each(
-          json_extract(channel_delete.value, '$.addedReferenceReleaseIds')
-        )
-      )
-    )`,
-		params: encodeD1Values([requiredRows.map(({ model, id }) => ({
-			model,
-			id
-		})), channelDeletes])
-	};
-	statements.push(...input.changes.map((change) => changeQuery(change, guard)));
-	return {
-		checks,
-		statements
-	};
-};
-const resultForPlan = (plan, results) => {
-	const missing = plan.checks.find(({ conflictWhen, resultIndex }) => conflictWhen === "empty" ? (results[resultIndex]?.length ?? 0) === 0 : (results[resultIndex]?.length ?? 0) > 0);
-	return missing === void 0 ? { committed: true } : {
-		committed: false,
-		conflict: {
-			changeIndex: missing.changeIndex,
-			reason: missing.reason
-		}
-	};
-};
-const insertChannel = async (executor, input) => {
-	const insert = insertQuery({
-		model: "channels",
-		data: input.row,
-		onConflict: "ignore"
-	}, void 0, "ignore");
-	const select = {
-		sql: "SELECT id, name FROM channels WHERE name = json_extract(?, '$') LIMIT 1",
-		params: encodeD1Values([input.row.name])
-	};
-	const [insertedRows = [], canonicalRows = []] = await executor.batch([insert, select]);
-	return {
-		row: parseD1Row("channels", canonicalRows[0]),
-		inserted: insertedRows.length > 0
-	};
-};
-const deleteChannel = async (executor, input) => {
-	const [channelRows = [], referenceRows = [], deletedRows = []] = await executor.batch([
-		{
-			sql: "SELECT id FROM channels WHERE id = json_extract(?, '$') LIMIT 1",
-			params: encodeD1Values([input.id])
-		},
-		{
-			sql: "SELECT id FROM releases WHERE channel_id = json_extract(?, '$') LIMIT 1",
-			params: encodeD1Values([input.id])
-		},
-		{
-			sql: "DELETE FROM channels WHERE id = json_extract(?, '$') AND NOT EXISTS (SELECT 1 FROM releases WHERE channel_id = json_extract(?, '$')) RETURNING id",
-			params: encodeD1Values([input.id, input.id])
-		}
-	]);
-	if (channelRows.length === 0) return {
-		deleted: false,
-		reason: "not_found"
-	};
-	if (referenceRows.length > 0) return {
-		deleted: false,
-		reason: "not_empty"
-	};
-	return deletedRows.length > 0 ? { deleted: true } : {
-		deleted: false,
-		reason: "not_empty"
-	};
+	const code = /UNIQUE constraint failed|constraint failed: .*PRIMARY/iu.test(message) ? "SQLITE_CONSTRAINT_UNIQUE" : /SQLITE_BUSY|database is locked/iu.test(message) ? "SQLITE_BUSY" : void 0;
+	return code === void 0 ? error : Object.assign(new Error(message, { cause: error }), { code });
 };
-const createD1Implementation = (executor) => ({
-	async create(input) {
-		const query = insertQuery(input);
-		const rows = await executor.query(query.sql, query.params);
-		switch (input.model) {
-			case "bundles": return parseD1Row("bundles", rows[0]);
-			case "bundle_patches": return parseD1Row("bundle_patches", rows[0]);
-			case "channels": return parseD1Row("channels", rows[0]);
-			case "bundle_events": return parseD1Row("bundle_events", rows[0]);
-			case "api_keys": return parseD1Row("api_keys", rows[0]);
-			case "releases": return parseD1Row("releases", rows[0]);
-			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
-		}
-	},
-	async update(input) {
-		const query = updateQuery(input);
-		const rows = await executor.query(query.sql, query.params);
-		if (rows[0] === void 0) return null;
-		switch (input.model) {
-			case "bundles": return parseD1Row("bundles", rows[0]);
-			case "api_keys": return parseD1Row("api_keys", rows[0]);
-			case "releases": return parseD1Row("releases", rows[0]);
-			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
-		}
-	},
-	async delete(input) {
-		const query = deleteQuery(input);
-		await executor.query(query.sql, query.params);
-	},
-	count: (input) => countD1Rows(executor, input),
-	async findOne(input) {
-		const where = buildD1Where(input.where);
-		const rows = await executor.query(`SELECT * FROM ${d1TableNames[input.model]}${where.sql} LIMIT 1`, where.params);
-		if (rows[0] === void 0) return null;
-		switch (input.model) {
-			case "bundles": return parseD1Row("bundles", rows[0]);
-			case "bundle_patches": return parseD1Row("bundle_patches", rows[0]);
-			case "channels": return parseD1Row("channels", rows[0]);
-			case "api_keys": return parseD1Row("api_keys", rows[0]);
-			case "releases": return parseD1Row("releases", rows[0]);
-			case "release_catalogs": return parseD1Row("release_catalogs", rows[0]);
-		}
-	},
-	findMany: (input) => findManyD1Rows(executor, input),
-	insertChannel: (input) => insertChannel(executor, input),
-	deleteChannel: (input) => deleteChannel(executor, input),
-	async commit(input) {
-		if (input.changes.length === 0) return { committed: true };
-		const expectations = input.expectations ?? [];
-		const conflict = await expectationConflict(executor, expectations);
-		if (conflict !== null) return conflict;
-		const plan = createCommitPlan(input);
-		try {
-			return resultForPlan(plan, await executor.batch(plan.statements));
-		} catch (error) {
-			if (expectations.length === 0 || !isExpectationConflictError(error)) throw error;
-			return await expectationConflict(executor, expectations) ?? {
-				committed: false,
-				conflict: {
-					actualVersion: expectations[0].model === "releases" ? expectations[0].revision : expectations[0].generation,
-					changeIndex: -1,
-					expectedVersion: expectations[0].model === "releases" ? expectations[0].revision : expectations[0].generation,
-					key: expectations[0].model === "releases" ? expectations[0].id : expectations[0].scopeKey,
-					model: expectations[0].model,
-					reason: "version_conflict"
+/**
+* Hot Updater's database on D1: the storage engine through the shared SQL
+* core, fenced by the schema settings. D1 has no interactive transactions,
+* so each write is one atomic batch that evaluates its guards first
+* (`_hu_write`).
+*/
+const createD1Database = (runner) => {
+	return (0, _hot_updater_server_database.createEngineDatabase)({
+		name: "d1Database",
+		adapter: (0, _hot_updater_server_database.createSqlAdapter)({
+			executor: {
+				dialect: "sqlite",
+				execute: (statement) => runner.query(statement).catch((error) => {
+					throw withSqliteCode(error);
+				}),
+				batch: (statements) => runner.batch(statements).catch((error) => {
+					throw withSqliteCode(error);
+				}),
+				transaction: () => {
+					throw new Error("D1 has no interactive transactions; writes are batches.");
 				}
-			};
-		}
-	}
-});
+			},
+			maxOps: 450,
+			maxParams: 100
+		})
+	});
+};
+//#endregion
+//#region src/d1Schema.ts
+/**
+* D1's schema: the guard table batch writes need, then the shared SQL
+* schema, settings last. Every statement can run again, so a migration for a
+* server's plugin tables repeats the built-in ones.
+*/
+const d1SchemaStatements = ({ schema, settings } = _hot_updater_server_database.builtInTarget) => [...(0, _hot_updater_server_database.createTableStatements)("sqlite", [_hot_updater_server_database.WRITE_GUARD_TABLE]), ...(0, _hot_updater_server_db.generateEngineSql)("sqlite", schema, settings)];
+/** The schema as a D1 migration, which `wrangler d1 migrations apply` runs. */
+const d1SchemaSql = (target) => `-- HotUpdater.schema\n\n${d1SchemaStatements(target).map((statement) => `${statement};`).join("\n\n")}\n`;
 //#endregion
 //#region src/d1Database.ts
+/** The REST API binds text: each value goes as JSON and is read back with `json_extract`. */
+const encode = ({ sql, params }) => ({
+	sql: sql.replaceAll("?", () => "json_extract(?, '$')"),
+	params: params.map((value) => JSON.stringify(value ?? null))
+});
+/**
+* Hot Updater's database on D1 through the Cloudflare REST API, for the CLI
+* and console. `hot-updater db generate` writes a D1 migration of the built-in
+* tables and the server's plugin tables to `migrations`, and
+* `hot-updater db migrate` applies them through the API.
+*/
 const d1Database = (config) => {
 	const cloudflare$1 = new cloudflare.default({ apiToken: config.cloudflareApiToken });
 	const execute = async (statements) => {
-		const first = statements[0];
+		const [first] = statements;
 		if (first === void 0) return [];
 		const body = statements.length === 1 ? {
 			account_id: config.accountId,
-			sql: first.sql,
-			params: [...first.params]
+			...encode(first)
 		} : {
 			account_id: config.accountId,
-			batch: statements.map(({ sql, params }) => ({
-				sql,
-				params: [...params]
-			}))
+			batch: statements.map(encode)
 		};
-		const page = await cloudflare$1.d1.database.query(config.databaseId, { ...body });
+		const page = await cloudflare$1.d1.database.query(config.databaseId, body);
 		const results = [];
-		for await (const resultPage of page.iterPages()) for (const result of resultPage.result) results.push(result.results ?? []);
+		for await (const resultPage of page.iterPages()) for (const result of resultPage.result) results.push(toSqlResult(result));
+		if (results.length !== statements.length) throw new D1ExecutionError();
 		return results;
 	};
-	const adapter = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("d1Database", createD1Implementation({
-		async query(sql, params) {
-			return (await execute([{
-				sql,
-				params
-			}])).flat();
-		},
-		batch: execute
-	}));
-	return (0, _hot_updater_plugin_core.createDatabasePlugin)({
-		name: "d1Database",
-		models: adapter.models,
-		commit: adapter.commit,
-		...adapter.dispose ? { dispose: adapter.dispose } : {}
-	});
+	return {
+		...createD1Database({
+			query: async (statement) => (await execute([statement]))[0],
+			batch: execute
+		}),
+		generateSchema: ((version, _name, target = _hot_updater_server_database.builtInTarget) => {
+			if (version !== "latest" && version !== _hot_updater_server_database.builtInSettings["schema.core"]) throw new Error(`Invalid version ${version}`);
+			const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 14);
+			return {
+				code: d1SchemaSql(target),
+				path: `migrations/${timestamp}_hot-updater.sql`
+			};
+		})
+	};
 };
 //#endregion
+//#region src/plugins.ts
+/**
+* The plugins the managed Cloudflare server runs: Insights, and API keys on every
+* client route. Its Worker imports this list.
+*/
+const plugins = [(0, _hot_updater_server_plugins_insights.insights)(), (0, _hot_updater_server_plugins_api_keys.apiKeys)()];
+//#endregion
 //#region ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
 	if (typeof value !== "object" || value === null) return false;
@@ -1044,7 +267,8 @@ const parseTemplate = ({ templates, expressions, tokens, index, template }) => {
 	const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
 	if (index === expressions.length) return newTokens;
 	const expression = expressions[index];
-	return concatTokens(newTokens, Array.isArray(expression) ? expression.map((expression) => parseExpression(expression)) : [parseExpression(expression)], trailingWhitespaces);
+	const expressionTokens = Array.isArray(expression) ? expression.map((expression) => parseExpression(expression)) : [parseExpression(expression)];
+	return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
 };
 const splitByWhitespaces = (template, rawTemplate) => {
 	if (rawTemplate.length === 0) return {
@@ -1077,7 +301,7 @@ const splitByWhitespaces = (template, rawTemplate) => {
 		trailingWhitespaces
 	};
 };
-const DELIMITERS = new Set([
+const DELIMITERS = /* @__PURE__ */ new Set([
 	" ",
 	"	",
 	"\r",
@@ -1129,7 +353,8 @@ const normalizeFdSpecificOptions = (options) => {
 };
 const normalizeFdSpecificOption = (options, optionName) => {
 	const optionBaseArray = Array.from({ length: getStdioLength(options) + 1 });
-	return addDefaultValue$1(normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName), optionName);
+	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
+	return addDefaultValue$1(optionArray, optionName);
 };
 const getStdioLength = ({ stdio }) => Array.isArray(stdio) ? Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length) : STANDARD_STREAMS_ALIASES.length;
 const normalizeFdSpecificValue = (optionValue, optionArray, optionName) => isPlainObject(optionValue) ? normalizeOptionObject(optionValue, optionArray, optionName) : optionArray.fill(optionValue);
@@ -1162,7 +387,7 @@ const addDefaultValue$1 = (optionArray, optionName) => optionArray.map((optionVa
 const DEFAULT_OPTIONS = {
 	lines: false,
 	buffer: true,
-	maxBuffer: 1e3 * 1e3 * 100,
+	maxBuffer: 1e8,
 	verbose: (0, node_util.debuglog)("execa").enabled ? "full" : "none",
 	stripFinalNewline: true
 };
@@ -1210,7 +435,7 @@ const escapeControlCharacter = (character) => {
 };
 const getSpecialCharRegExp = () => {
 	try {
-		return /* @__PURE__ */ new RegExp("\\p{Separator}|\\p{Other}", "gu");
+		return new RegExp("\\p{Separator}|\\p{Other}", "gu");
 	} catch {
 		return /[\s\u0000-\u001F\u007F-\u009F\u00AD]/g;
 	}
@@ -1630,11 +855,13 @@ const appendNewline = (printedLine) => printedLine.endsWith("\n") ? printedLine
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/log.js
 const verboseLog = ({ type, verboseMessage, fdNumber, verboseInfo, result }) => {
-	const finalLines = applyVerboseOnLines(getPrintedLines(verboseMessage, getVerboseObject({
+	const verboseObject = getVerboseObject({
 		type,
 		result,
 		verboseInfo
-	})), verboseInfo, fdNumber);
+	});
+	const printedLines = getPrintedLines(verboseMessage, verboseObject);
+	const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
 	if (finalLines !== "") console.warn(finalLines.slice(0, -1));
 };
 const getVerboseObject = ({ type, result, verboseInfo: { escapedCommand, commandId, rawOptions: { piped = false, ...options } } }) => ({
@@ -1657,7 +884,8 @@ const getPrintedLine = (verboseObject) => {
 	};
 };
 const serializeVerboseMessage = (message) => {
-	return escapeLines(typeof message === "string" ? message : (0, node_util.inspect)(message)).replaceAll("	", " ".repeat(TAB_SIZE));
+	const messageString = typeof message === "string" ? message : (0, node_util.inspect)(message);
+	return escapeLines(messageString).replaceAll("	", " ".repeat(TAB_SIZE));
 };
 const TAB_SIZE = 2;
 //#endregion
@@ -1702,7 +930,8 @@ const getDurationMs = (startTime) => Number(node_process.hrtime.bigint() - start
 const handleCommand = (filePath, rawArguments, rawOptions) => {
 	const startTime = getStartTime();
 	const { command, escapedCommand } = joinCommand(filePath, rawArguments);
-	const verboseInfo = getVerboseInfo(normalizeFdSpecificOption(rawOptions, "verbose"), escapedCommand, { ...rawOptions });
+	const verbose = normalizeFdSpecificOption(rawOptions, "verbose");
+	const verboseInfo = getVerboseInfo(verbose, escapedCommand, { ...rawOptions });
 	logCommand(escapedCommand, verboseInfo);
 	return {
 		command,
@@ -1823,7 +1052,8 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
 	const getPathInfo = (cmd, opt) => {
 		const colon = opt.colon || COLON;
-		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || "").split(colon)];
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || 
+		/* istanbul ignore next: very unusual */ "").split(colon)];
 		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
 		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
 		if (isWindows) {
@@ -1848,14 +1078,17 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const ppRaw = pathEnv[i];
 			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
 			const pCmd = path$13.join(pathPart, cmd);
-			resolve(subStep(!pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd, i, 0));
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
 		});
 		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
 			if (ii === pathExt.length) return resolve(step(i + 1));
 			const ext = pathExt[ii];
 			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-				if (!er && is) if (opt.all) found.push(p + ext);
-				else return resolve(p + ext);
+				if (!er && is) {
+					if (opt.all) found.push(p + ext);
+					else return resolve(p + ext);
+				}
 				return resolve(subStep(p, i, ii + 1));
 			});
 		});
@@ -1873,8 +1106,10 @@ var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			for (let j = 0; j < pathExt.length; j++) {
 				const cur = p + pathExt[j];
 				try {
-					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
-					else return cur;
+					if (isexe.sync(cur, { pathExt: pathExtExe })) {
+						if (opt.all) found.push(cur);
+						else return cur;
+					}
 				} catch (ex) {}
 			}
 		}
@@ -2565,7 +1800,7 @@ const normalizeForceKillAfterDelay = (forceKillAfterDelay) => {
 	if (!Number.isFinite(forceKillAfterDelay) || forceKillAfterDelay < 0) throw new TypeError(`Expected the \`forceKillAfterDelay\` option to be a non-negative integer, got \`${forceKillAfterDelay}\` (${typeof forceKillAfterDelay})`);
 	return forceKillAfterDelay;
 };
-const DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+const DEFAULT_FORCE_KILL_TIMEOUT = 5e3;
 const subprocessKill = ({ kill, options: { forceKillAfterDelay, killSignal }, onInternalError, context, controller }, signalOrError, errorArgument) => {
 	const { signal, error } = parseKillArguments(signalOrError, errorArgument, killSignal);
 	emitKillError(error, onInternalError);
@@ -2667,7 +1902,7 @@ const handleSerializationError = ({ error, methodName, isSubprocess, message })
 	if (isSerializationError(error)) throw new Error(`${getMethodName(methodName, isSubprocess)}'s argument type is invalid: the message cannot be serialized: ${String(message)}.`, { cause: error });
 };
 const isSerializationError = ({ code, message }) => SERIALIZATION_ERROR_CODES.has(code) || SERIALIZATION_ERROR_MESSAGES.some((serializationErrorMessage) => message.includes(serializationErrorMessage));
-const SERIALIZATION_ERROR_CODES = new Set(["ERR_MISSING_ARGS", "ERR_INVALID_ARG_TYPE"]);
+const SERIALIZATION_ERROR_CODES = /* @__PURE__ */ new Set(["ERR_MISSING_ARGS", "ERR_INVALID_ARG_TYPE"]);
 const SERIALIZATION_ERROR_MESSAGES = [
 	"could not be cloned",
 	"circular structure",
@@ -2877,7 +2112,8 @@ const isConnected = (anyProcess) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/ipc/strict.js
 const handleSendStrict = ({ anyProcess, channel, isSubprocess, message, strict }) => {
 	if (!strict) return message;
-	const hasListeners = hasMessageListeners(anyProcess, getIpcEmitter(anyProcess, channel, isSubprocess));
+	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
+	const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
 	return {
 		id: count++,
 		type: REQUEST_TYPE,
@@ -3109,7 +2345,8 @@ const throwOnGracefulCancel = ({ subprocess, cancelSignal, gracefulCancel, force
 })] : [];
 const sendOnAbort = async ({ subprocess, cancelSignal, forceKillAfterDelay, context, controller: { signal } }) => {
 	await onAbortedSignal(cancelSignal, signal);
-	await sendAbort(subprocess, getReason(cancelSignal));
+	const reason = getReason(cancelSignal);
+	await sendAbort(subprocess, reason);
 	killOnTimeout({
 		kill: subprocess.kill,
 		forceKillAfterDelay,
@@ -3221,8 +2458,8 @@ Please rename it to ${serializeEncoding(correctEncoding)}.`);
 	throw new TypeError(`Invalid option \`encoding: ${serializeEncoding(encoding)}\`.
 Please rename it to one of: ${correctEncodings}.`);
 };
-const TEXT_ENCODINGS = new Set(["utf8", "utf16le"]);
-const BINARY_ENCODINGS = new Set([
+const TEXT_ENCODINGS = /* @__PURE__ */ new Set(["utf8", "utf16le"]);
+const BINARY_ENCODINGS = /* @__PURE__ */ new Set([
 	"buffer",
 	"hex",
 	"base64",
@@ -3230,7 +2467,7 @@ const BINARY_ENCODINGS = new Set([
 	"latin1",
 	"ascii"
 ]);
-const ENCODINGS = new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
+const ENCODINGS = /* @__PURE__ */ new Set([...TEXT_ENCODINGS, ...BINARY_ENCODINGS]);
 const getCorrectEncoding = (encoding) => {
 	if (encoding === null) return "buffer";
 	if (typeof encoding !== "string") return;
@@ -3277,7 +2514,8 @@ const normalizeOptions = (filePath, rawArguments, rawOptions) => {
 	rawOptions.cwd = normalizeCwd(rawOptions.cwd);
 	const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
 	const { command: file, args: commandArguments, options: initialOptions } = import_cross_spawn.default._parse(processedFile, processedArguments, processedOptions);
-	const options = addDefaultOptions(normalizeFdSpecificOptions(initialOptions));
+	const fdOptions = normalizeFdSpecificOptions(initialOptions);
+	const options = addDefaultOptions(fdOptions);
 	validateTimeout(options);
 	validateEncoding(options);
 	validateIpcInputOption(options);
@@ -3478,14 +2716,17 @@ const getStreamContents$1 = async (stream, { init, convertChunk, getSize, trunca
 	const state = init();
 	state.length = 0;
 	try {
-		for await (const chunk of asyncIterable) appendChunk({
-			convertedChunk: convertChunk[getChunkType(chunk)](chunk, state),
-			state,
-			getSize,
-			truncateChunk,
-			addChunk,
-			maxBuffer
-		});
+		for await (const chunk of asyncIterable) {
+			const convertedChunk = convertChunk[getChunkType(chunk)](chunk, state);
+			appendChunk({
+				convertedChunk,
+				state,
+				getSize,
+				truncateChunk,
+				addChunk,
+				maxBuffer
+			});
+		}
 		appendFinalChunk({
 			state,
 			convertChunk,
@@ -3771,7 +3012,8 @@ const getErrorPrefix = ({ originalError, timedOut, timeout, isMaxBuffer, maxBuff
 const getForcefulSuffix = (isForcefullyTerminated, forceKillAfterDelay) => isForcefullyTerminated ? ` and was forcefully terminated after ${forceKillAfterDelay} milliseconds` : "";
 const getOriginalMessage = (originalError, cwd) => {
 	if (originalError instanceof DiscardedError) return;
-	const escapedOriginalMessage = escapeLines(fixCwdError(isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError), cwd));
+	const originalMessage = isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError);
+	const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
 	return escapedOriginalMessage === "" ? void 0 : escapedOriginalMessage;
 };
 const serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : (0, node_util.inspect)(ipcMessage);
@@ -3982,26 +3224,28 @@ function prettyMilliseconds(milliseconds, options) {
 		add(Number(parsed.hours), "hour", "h");
 	}
 	add(Number(parsed.minutes), "minute", "m");
-	if (!options.hideSeconds) if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3 && !options.subSecondsAsDecimals) {
-		const seconds = Number(parsed.seconds);
-		const milliseconds = Number(parsed.milliseconds);
-		const microseconds = Number(parsed.microseconds);
-		const nanoseconds = Number(parsed.nanoseconds);
-		add(seconds, "second", "s");
-		if (options.formatSubMilliseconds) {
-			add(milliseconds, "millisecond", "ms");
-			add(microseconds, "microsecond", "µs");
-			add(nanoseconds, "nanosecond", "ns");
+	if (!options.hideSeconds) {
+		if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3 && !options.subSecondsAsDecimals) {
+			const seconds = Number(parsed.seconds);
+			const milliseconds = Number(parsed.milliseconds);
+			const microseconds = Number(parsed.microseconds);
+			const nanoseconds = Number(parsed.nanoseconds);
+			add(seconds, "second", "s");
+			if (options.formatSubMilliseconds) {
+				add(milliseconds, "millisecond", "ms");
+				add(microseconds, "microsecond", "µs");
+				add(nanoseconds, "nanosecond", "ns");
+			} else {
+				const millisecondsAndBelow = milliseconds + microseconds / 1e3 + nanoseconds / 1e6;
+				const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
+				const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
+				add(Number.parseFloat(millisecondsString), "millisecond", "ms", millisecondsString);
+			}
 		} else {
-			const millisecondsAndBelow = milliseconds + microseconds / 1e3 + nanoseconds / 1e6;
-			const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
-			const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
-			add(Number.parseFloat(millisecondsString), "millisecond", "ms", millisecondsString);
+			const secondsFixed = floorDecimals((isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60, typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1);
+			const secondsString = options.keepDecimalsOnWholeSeconds ? secondsFixed : secondsFixed.replace(/\.0+$/, "");
+			add(Number.parseFloat(secondsString), "second", "s", secondsString);
 		}
-	} else {
-		const secondsFixed = floorDecimals((isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60, typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1);
-		const secondsString = options.keepDecimalsOnWholeSeconds ? secondsFixed : secondsFixed.replace(/\.0+$/, "");
-		add(Number.parseFloat(secondsString), "second", "s", secondsString);
 	}
 	if (result.length === 0) return sign + "0" + (options.verbose ? " milliseconds" : "ms");
 	const separator = options.colonNotation ? ":" : " ";
@@ -4026,9 +3270,10 @@ const logResult = (result, verboseInfo) => {
 	logDuration(result, verboseInfo);
 };
 const logDuration = (result, verboseInfo) => {
+	const verboseMessage = `(done in ${prettyMilliseconds(result.durationMs)})`;
 	verboseLog({
 		type: "duration",
-		verboseMessage: `(done in ${prettyMilliseconds(result.durationMs)})`,
+		verboseMessage,
 		verboseInfo,
 		result
 	});
@@ -4096,10 +3341,10 @@ const isTransformOptions = (value) => isPlainObject(value) && (value.transform !
 const isUrl = (value) => Object.prototype.toString.call(value) === "[object URL]";
 const isRegularUrl = (value) => isUrl(value) && value.protocol !== "file:";
 const isFilePathObject = (value) => isPlainObject(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => FILE_PATH_KEYS.has(key)) && isFilePathString(value.file);
-const FILE_PATH_KEYS = new Set(["file", "append"]);
+const FILE_PATH_KEYS = /* @__PURE__ */ new Set(["file", "append"]);
 const isFilePathString = (file) => typeof file === "string";
 const isUnknownStdioString = (type, value) => type === "native" && typeof value === "string" && !KNOWN_STDIO_STRINGS.has(value);
-const KNOWN_STDIO_STRINGS = new Set([
+const KNOWN_STDIO_STRINGS = /* @__PURE__ */ new Set([
 	"ipc",
 	"ignore",
 	"inherit",
@@ -4113,24 +3358,24 @@ const isTransformStream = (value) => isReadableStream(value?.readable) && isWrit
 const isAsyncIterableObject = (value) => isObject(value) && typeof value[Symbol.asyncIterator] === "function";
 const isIterableObject = (value) => isObject(value) && typeof value[Symbol.iterator] === "function";
 const isObject = (value) => typeof value === "object" && value !== null;
-const TRANSFORM_TYPES = new Set([
+const TRANSFORM_TYPES = /* @__PURE__ */ new Set([
 	"generator",
 	"asyncGenerator",
 	"duplex",
 	"webTransform"
 ]);
-const FILE_TYPES = new Set([
+const FILE_TYPES = /* @__PURE__ */ new Set([
 	"fileUrl",
 	"filePath",
 	"fileNumber"
 ]);
-const SPECIAL_DUPLICATE_TYPES_SYNC = new Set(["fileUrl", "filePath"]);
-const SPECIAL_DUPLICATE_TYPES = new Set([
+const SPECIAL_DUPLICATE_TYPES_SYNC = /* @__PURE__ */ new Set(["fileUrl", "filePath"]);
+const SPECIAL_DUPLICATE_TYPES = /* @__PURE__ */ new Set([
 	...SPECIAL_DUPLICATE_TYPES_SYNC,
 	"webStream",
 	"nodeStream"
 ]);
-const FORBID_DUPLICATE_TYPES = new Set(["webTransform", "duplex"]);
+const FORBID_DUPLICATE_TYPES = /* @__PURE__ */ new Set(["webTransform", "duplex"]);
 const TYPE_TO_MESSAGE = {
 	generator: "a generator",
 	asyncGenerator: "an async generator",
@@ -4463,7 +3708,8 @@ const validateDuplicateStreamSync = ({ otherStdioItems, type, value, optionName,
 const getDuplicateStreamInstance = ({ otherStdioItems, type, value, optionName, direction }) => {
 	const duplicateStdioItems = otherStdioItems.filter((stdioItem) => hasSameValue(stdioItem, value));
 	if (duplicateStdioItems.length === 0) return;
-	throwOnDuplicateStream(duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction), optionName, type);
+	const differentStdioItem = duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction);
+	throwOnDuplicateStream(differentStdioItem, optionName, type);
 	return direction === "output" ? duplicateStdioItems[0].stream : void 0;
 };
 const hasSameValue = ({ type, value }, secondValue) => {
@@ -4472,7 +3718,8 @@ const hasSameValue = ({ type, value }, secondValue) => {
 	return value === secondValue;
 };
 const validateDuplicateTransform = ({ otherStdioItems, type, value, optionName }) => {
-	throwOnDuplicateStream(otherStdioItems.find(({ value: { transform } }) => transform === value.transform), optionName, type);
+	const duplicateStdioItem = otherStdioItems.find(({ value: { transform } }) => transform === value.transform);
+	throwOnDuplicateStream(duplicateStdioItem, optionName, type);
 };
 const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 	if (stdioItem !== void 0) throw new TypeError(`The \`${stdioItem.optionName}\` and \`${optionName}\` options must not target ${TYPE_TO_MESSAGE[type]} that is the same.`);
@@ -4480,13 +3727,14 @@ const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/stdio/handle.js
 const handleStdio = (addProperties, options, verboseInfo, isSync) => {
+	const initialFileDescriptors = normalizeStdioOption(options, verboseInfo, isSync).map((stdioOption, fdNumber) => getFileDescriptor({
+		stdioOption,
+		fdNumber,
+		options,
+		isSync
+	}));
 	const fileDescriptors = getFinalFileDescriptors({
-		initialFileDescriptors: normalizeStdioOption(options, verboseInfo, isSync).map((stdioOption, fdNumber) => getFileDescriptor({
-			stdioOption,
-			fdNumber,
-			options,
-			isSync
-		})),
+		initialFileDescriptors,
 		addProperties,
 		options,
 		isSync
@@ -4503,13 +3751,14 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 		optionName
 	});
 	const direction = getStreamDirection(initialStdioItems, fdNumber, optionName);
-	const normalizedStdioItems = normalizeTransforms(initialStdioItems.map((stdioItem) => handleNativeStream({
+	const stdioItems = initialStdioItems.map((stdioItem) => handleNativeStream({
 		stdioItem,
 		isStdioArray,
 		fdNumber,
 		direction,
 		isSync
-	})), optionName, direction, options);
+	}));
+	const normalizedStdioItems = normalizeTransforms(stdioItems, optionName, direction, options);
 	const objectMode = getFdObjectMode(normalizedStdioItems, direction);
 	validateFileObjectMode(normalizedStdioItems, objectMode);
 	return {
@@ -4519,7 +3768,8 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 	};
 };
 const initializeStdioItems = ({ stdioOption, fdNumber, options, optionName }) => {
-	const stdioItems = filterDuplicates([...(Array.isArray(stdioOption) ? stdioOption : [stdioOption]).map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)]);
+	const initialStdioItems = [...(Array.isArray(stdioOption) ? stdioOption : [stdioOption]).map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)];
+	const stdioItems = filterDuplicates(initialStdioItems);
 	const isStdioArray = stdioItems.length > 1;
 	validateStdioArray(stdioItems, isStdioArray, optionName);
 	validateStreams(stdioItems);
@@ -4538,7 +3788,7 @@ const validateStdioArray = (stdioItems, isStdioArray, optionName) => {
 	if (!isStdioArray) return;
 	for (const { value, optionName } of stdioItems) if (INVALID_STDIO_ARRAY_OPTIONS.has(value)) throw new Error(`The \`${optionName}\` option must not include \`${value}\`.`);
 };
-const INVALID_STDIO_ARRAY_OPTIONS = new Set(["ignore", "ipc"]);
+const INVALID_STDIO_ARRAY_OPTIONS = /* @__PURE__ */ new Set(["ignore", "ipc"]);
 const validateStreams = (stdioItems) => {
 	for (const stdioItem of stdioItems) validateFileStdio(stdioItem);
 };
@@ -4867,7 +4117,10 @@ const generatorToStream = ({ value, value: { transform, final, writableObjectMod
 const runGeneratorsSync = (chunks, stdioItems, encoding, isInput) => {
 	const generators = stdioItems.filter(({ type }) => type === "generator");
 	const reversedGenerators = isInput ? generators.reverse() : generators;
-	for (const { value, optionName } of reversedGenerators) chunks = runTransformSync(addInternalGenerators(value, encoding, optionName), chunks);
+	for (const { value, optionName } of reversedGenerators) {
+		const generators = addInternalGenerators(value, encoding, optionName);
+		chunks = runTransformSync(generators, chunks);
+	}
 	return chunks;
 };
 const addInternalGenerators = ({ transform, final, binary, writableObjectMode, readableObjectMode, preserveNewlines }, encoding, optionName) => {
@@ -4903,7 +4156,8 @@ const addInputOptionSync = (fileDescriptors, fdNumber, options) => {
 		const [{ type, optionName }] = allStdioItems;
 		throw new TypeError(`Only the \`stdin\` option, not \`${optionName}\`, can be ${TYPE_TO_MESSAGE[type]} with synchronous methods.`);
 	}
-	options.input = joinToUint8Array(allStdioItems.map(({ contents }) => contents).map((contents) => applySingleInputGeneratorsSync(contents, stdioItems)));
+	const transformedContents = allStdioItems.map(({ contents }) => contents).map((contents) => applySingleInputGeneratorsSync(contents, stdioItems));
+	options.input = joinToUint8Array(transformedContents);
 };
 const applySingleInputGeneratorsSync = (contents, stdioItems) => {
 	const newContents = runGeneratorsSync(contents, stdioItems, "utf8", true);
@@ -4918,7 +4172,7 @@ const validateSerializable = (newContents) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/output.js
 const shouldLogOutput = ({ stdioItems, encoding, verboseInfo, fdNumber }) => fdNumber !== "all" && isFullVerbose(verboseInfo, fdNumber) && !BINARY_ENCODINGS.has(encoding) && fdUsesVerbose(fdNumber) && (stdioItems.some(({ type, value }) => type === "native" && PIPED_STDIO_VALUES.has(value)) || stdioItems.every(({ type }) => TRANSFORM_TYPES.has(type)));
 const fdUsesVerbose = (fdNumber) => fdNumber === 1 || fdNumber === 2;
-const PIPED_STDIO_VALUES = new Set(["pipe", "overlapped"]);
+const PIPED_STDIO_VALUES = /* @__PURE__ */ new Set(["pipe", "overlapped"]);
 const logLines = async (linesIterable, stream, fdNumber, verboseInfo) => {
 	for await (const line of linesIterable) if (!isPipingStream(stream)) logLine(line, fdNumber, verboseInfo);
 };
@@ -4927,9 +4181,10 @@ const logLinesSync = (linesArray, fdNumber, verboseInfo) => {
 };
 const isPipingStream = (stream) => stream._readableState.pipes.length > 0;
 const logLine = (line, fdNumber, verboseInfo) => {
+	const verboseMessage = serializeVerboseMessage(line);
 	verboseLog({
 		type: "output",
-		verboseMessage: serializeVerboseMessage(line),
+		verboseMessage,
 		fdNumber,
 		verboseInfo
 	});
@@ -4955,10 +4210,12 @@ const transformOutputSync = ({ fileDescriptors, syncResult: { output }, options,
 };
 const transformOutputResultSync = ({ result, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo }, { buffer, encoding, lines, stripFinalNewline, maxBuffer }) => {
 	if (result === null) return;
-	const uint8ArrayResult = bufferToUint8Array(truncateMaxBufferSync(result, isMaxBuffer, maxBuffer));
+	const truncatedResult = truncateMaxBufferSync(result, isMaxBuffer, maxBuffer);
+	const uint8ArrayResult = bufferToUint8Array(truncatedResult);
 	const { stdioItems, objectMode } = fileDescriptors[fdNumber];
+	const chunks = runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state);
 	const { serializedResult, finalResult = serializedResult } = serializeChunks({
-		chunks: runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state),
+		chunks,
 		objectMode,
 		encoding,
 		lines,
@@ -5082,7 +4339,7 @@ const getResultError = (error, exitCode, signal) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/methods/main-sync.js
 const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 	const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleSyncArguments(rawFile, rawArguments, rawOptions);
-	return handleResult(spawnSubprocessSync({
+	const result = spawnSubprocessSync({
 		file,
 		commandArguments,
 		options,
@@ -5091,11 +4348,13 @@ const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 		verboseInfo,
 		fileDescriptors,
 		startTime
-	}), verboseInfo, options);
+	});
+	return handleResult(result, verboseInfo, options);
 };
 const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
-	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, normalizeSyncOptions(rawOptions));
+	const syncOptions = normalizeSyncOptions(rawOptions);
+	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, syncOptions);
 	validateSyncOptions(options);
 	return {
 		file,
@@ -5140,14 +4399,16 @@ const spawnSubprocessSync = ({ file, commandArguments, options, command, escaped
 		isMaxBuffer,
 		verboseInfo
 	});
+	const stdio = output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber));
+	const all = stripNewline(getAllSync(output, options), options, "all");
 	return getSyncResult({
 		error,
 		exitCode,
 		signal,
 		timedOut,
 		isMaxBuffer,
-		stdio: output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber)),
-		all: stripNewline(getAllSync(output, options), options, "all"),
+		stdio,
+		all,
 		options,
 		command,
 		escapedCommand,
@@ -5157,7 +4418,8 @@ const spawnSubprocessSync = ({ file, commandArguments, options, command, escaped
 const runSubprocessSync = ({ file, commandArguments, options, command, escapedCommand, fileDescriptors, startTime }) => {
 	try {
 		addInputOptionsSync(fileDescriptors, options);
-		return (0, node_child_process.spawnSync)(file, commandArguments, normalizeSpawnSyncOptions(options));
+		const normalizedOptions = normalizeSpawnSyncOptions(options);
+		return (0, node_child_process.spawnSync)(file, commandArguments, normalizedOptions);
 	} catch (error) {
 		return makeEarlyError({
 			error,
@@ -5371,17 +4633,18 @@ const handleEarlyError = ({ error, command, escapedCommand, fileDescriptors, opt
 		writable,
 		duplex
 	});
+	const earlyError = makeEarlyError({
+		error,
+		command,
+		escapedCommand,
+		fileDescriptors,
+		options,
+		startTime,
+		isSync: false
+	});
 	return {
 		subprocess,
-		promise: handleDummyPromise(makeEarlyError({
-			error,
-			command,
-			escapedCommand,
-			fileDescriptors,
-			options,
-			startTime,
-			isSync: false
-		}), verboseInfo, options)
+		promise: handleDummyPromise(earlyError, verboseInfo, options)
 	};
 };
 const createDummyStreams = (subprocess, fileDescriptors) => {
@@ -5565,8 +4828,10 @@ const endWhenStreamsDone = async ({ passThroughStream, stream, streams, ended, a
 		controller.abort();
 		updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
 	}
-	if (streams.size > 0 && streams.size === ended.size + aborted.size) if (ended.size === 0 && aborted.size > 0) abortStream(passThroughStream);
-	else endStream(passThroughStream);
+	if (streams.size > 0 && streams.size === ended.size + aborted.size) {
+		if (ended.size === 0 && aborted.size > 0) abortStream(passThroughStream);
+		else endStream(passThroughStream);
+	}
 };
 const afterMergedStreamFinished = async (onFinished, stream, { signal }) => {
 	try {
@@ -5672,7 +4937,10 @@ const pipeOutputAsync = (subprocess, fileDescriptors, controller) => {
 			controller
 		});
 	}
-	for (const [outputStream, inputStreams] of pipeGroups.entries()) pipeStreams(inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams), outputStream);
+	for (const [outputStream, inputStreams] of pipeGroups.entries()) {
+		const inputStream = inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams);
+		pipeStreams(inputStream, outputStream);
+	}
 };
 const pipeTransform = (subprocess, stream, direction, fdNumber) => {
 	if (direction === "output") pipeStreams(subprocess.stdio[fdNumber], stream);
@@ -6161,12 +5429,13 @@ const stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
 	}
 };
 const iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
+	const onStdoutChunk = (0, node_events.on)(stream, "data", {
+		signal: controller.signal,
+		highWaterMark: HIGH_WATER_MARK,
+		highWatermark: HIGH_WATER_MARK
+	});
 	return iterateOnData({
-		onStdoutChunk: (0, node_events.on)(stream, "data", {
-			signal: controller.signal,
-			highWaterMark: HIGH_WATER_MARK,
-			highWatermark: HIGH_WATER_MARK
-		}),
+		onStdoutChunk,
 		controller,
 		binary,
 		shouldEncode,
@@ -6210,12 +5479,13 @@ const getStreamOutput = async ({ stream, onStreamEnd, fdNumber, encoding, buffer
 		await Promise.all([resumeStream(stream), logPromise]);
 		return;
 	}
+	const stripFinalNewlineValue = getStripFinalNewline(stripFinalNewline, fdNumber);
 	const iterable = iterateForResult({
 		stream,
 		onStreamEnd,
 		lines,
 		encoding,
-		stripFinalNewline: getStripFinalNewline(stripFinalNewline, fdNumber),
+		stripFinalNewline: stripFinalNewlineValue,
 		allMixed
 	});
 	const [output] = await Promise.all([getStreamContents({
@@ -6235,14 +5505,15 @@ const logOutputAsync = async ({ stream, onStreamEnd, fdNumber, encoding, allMixe
 		verboseInfo,
 		fdNumber
 	})) return;
-	await logLines(iterateForResult({
+	const linesIterable = iterateForResult({
 		stream,
 		onStreamEnd,
 		lines: true,
 		encoding,
 		stripFinalNewline: true,
 		allMixed
-	}), stream, fdNumber, verboseInfo);
+	});
+	await logLines(linesIterable, stream, fdNumber, verboseInfo);
 };
 const resumeStream = async (stream) => {
 	await (0, node_timers_promises.setImmediate)();
@@ -6388,9 +5659,10 @@ const getAllMixed = ({ all, stdout, stderr }) => all && stdout && stderr && stdo
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/ipc.js
 const shouldLogIpc = (verboseInfo) => isFullVerbose(verboseInfo, "ipc");
 const logIpcOutput = (message, verboseInfo) => {
+	const verboseMessage = serializeVerboseMessage(message);
 	verboseLog({
 		type: "ipc",
-		verboseMessage: serializeVerboseMessage(message),
+		verboseMessage,
 		fdNumber: "ipc",
 		verboseInfo
 	});
@@ -6786,14 +6058,15 @@ const onDuplexDestroy = async ({ subprocessStdout, subprocessStdin, subprocess,
 const createIterable = (subprocess, encoding, { from, binary: binaryOption = false, preserveNewlines = false } = {}) => {
 	const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
 	const subprocessStdout = getFromStream(subprocess, from);
-	return iterateOnStdoutData(iterateOnSubprocessStream({
+	const onStdoutData = iterateOnSubprocessStream({
 		subprocessStdout,
 		subprocess,
 		binary,
 		shouldEncode: true,
 		encoding,
 		preserveNewlines
-	}), subprocessStdout, subprocess);
+	});
+	return iterateOnStdoutData(onStdoutData, subprocessStdout, subprocess);
 };
 const iterateOnStdoutData = async function* (onStdoutData, subprocessStdout, subprocess) {
 	try {
@@ -6953,19 +6226,22 @@ const handlePromise = async ({ subprocess, options, startTime, verboseInfo, file
 	});
 	controller.abort();
 	onInternalError.resolve();
-	return handleResult(getAsyncResult({
+	const stdio = stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber));
+	const all = stripNewline(allResult, options, "all");
+	const result = getAsyncResult({
 		errorInfo,
 		exitCode,
 		signal,
-		stdio: stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber)),
-		all: stripNewline(allResult, options, "all"),
+		stdio,
+		all,
 		ipcOutput,
 		context,
 		options,
 		command,
 		escapedCommand,
 		startTime
-	}), verboseInfo, options);
+	});
+	return handleResult(result, verboseInfo, options);
 };
 const getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, ipcOutput, context, options, command, escapedCommand, startTime }) => "error" in errorInfo ? makeError({
 	error: errorInfo.error,
@@ -7009,7 +6285,7 @@ const mergeOption = (optionName, boundOptionValue, optionValue) => {
 	};
 	return optionValue;
 };
-const DEEP_OPTIONS = new Set(["env", ...FD_SPECIFIC_OPTIONS]);
+const DEEP_OPTIONS = /* @__PURE__ */ new Set(["env", ...FD_SPECIFIC_OPTIONS]);
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/methods/create.js
 const createExeca = (mapArguments, boundOptions, deepOptions, setBoundExeca) => {
@@ -7036,7 +6312,8 @@ const callBoundExeca = ({ mapArguments, deepOptions = {}, boundOptions = {}, set
 	return isSync ? execaCoreSync(file, commandArguments, options) : execaCoreAsync(file, commandArguments, options, createNested);
 };
 const parseArguments = ({ mapArguments, firstArgument, nextArguments, deepOptions, boundOptions }) => {
-	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments]);
+	const callArguments = isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments];
+	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...callArguments);
 	const mergedOptions = mergeOptions(mergeOptions(deepOptions, boundOptions), initialOptions);
 	const { file = initialFile, commandArguments = initialArguments, options = mergedOptions, isSync = false } = mapArguments({
 		file: initialFile,
@@ -7150,6 +6427,8 @@ const isCloudflareAuthenticationError = (error) => {
 	].some((pattern) => pattern.test(getErrorOutput(error)));
 };
 var CloudflareAuthenticationError = class extends _hot_updater_cli_tools.InitError {
+	source;
+	accountId;
 	name = "CloudflareAuthenticationError";
 	constructor(source, accountId, options) {
 		super([
@@ -7164,6 +6443,7 @@ var CloudflareAuthenticationError = class extends _hot_updater_cli_tools.InitErr
 	}
 };
 var CloudflarePermissionError = class extends _hot_updater_cli_tools.InitError {
+	source;
 	name = "CloudflarePermissionError";
 	constructor(source, { accountId, check, requiredPermission }, options) {
 		super([
@@ -9302,12 +8582,14 @@ var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						s2 = peg$FAILED;
 						if (peg$silentFails === 0) peg$fail(peg$c39);
 					}
-					if (s2 === peg$FAILED) if (input.charCodeAt(peg$currPos) === 69) {
-						s2 = peg$c40;
-						peg$currPos++;
-					} else {
-						s2 = peg$FAILED;
-						if (peg$silentFails === 0) peg$fail(peg$c41);
+					if (s2 === peg$FAILED) {
+						if (input.charCodeAt(peg$currPos) === 69) {
+							s2 = peg$c40;
+							peg$currPos++;
+						} else {
+							s2 = peg$FAILED;
+							if (peg$silentFails === 0) peg$fail(peg$c41);
+						}
 					}
 					if (s2 !== peg$FAILED) {
 						s3 = peg$parseinteger_text();
@@ -10476,12 +9758,14 @@ var require_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 														s11 = peg$FAILED;
 														if (peg$silentFails === 0) peg$fail(peg$c48);
 													}
-													if (s11 === peg$FAILED) if (input.charCodeAt(peg$currPos) === 43) {
-														s11 = peg$c44;
-														peg$currPos++;
-													} else {
-														s11 = peg$FAILED;
-														if (peg$silentFails === 0) peg$fail(peg$c45);
+													if (s11 === peg$FAILED) {
+														if (input.charCodeAt(peg$currPos) === 43) {
+															s11 = peg$c44;
+															peg$currPos++;
+														} else {
+															s11 = peg$FAILED;
+															if (peg$silentFails === 0) peg$fail(peg$c45);
+														}
 													}
 													if (s11 !== peg$FAILED) {
 														s12 = peg$parseDIGIT_OR_UNDER();
@@ -11238,9 +10522,7 @@ var require_compiler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					case "ObjectPath":
 						setPath(node);
 						break;
-					case "ArrayPath":
-						addTableArray(node);
-						break;
+					case "ArrayPath": addTableArray(node);
 				}
 			}
 			return data;
@@ -11320,9 +10602,10 @@ var require_compiler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				var key = keys[i];
 				traversed.push(key);
 				traversedPath = traversed.join(".");
-				if (typeof ctx[key] === "undefined") if (i === keys.length - 1) ctx[key] = value;
-				else ctx[key] = Object.create(null);
-				else if (i !== keys.length - 1 && valueAssignments.indexOf(traversedPath) > -1) genError("Cannot redefine existing key '" + traversedPath + "'.", line, column);
+				if (typeof ctx[key] === "undefined") {
+					if (i === keys.length - 1) ctx[key] = value;
+					else ctx[key] = Object.create(null);
+				} else if (i !== keys.length - 1 && valueAssignments.indexOf(traversedPath) > -1) genError("Cannot redefine existing key '" + traversedPath + "'.", line, column);
 				ctx = ctx[key];
 				if (ctx instanceof Array && ctx.length && i < keys.length - 1) ctx = ctx[ctx.length - 1];
 			}
@@ -12115,7 +11398,7 @@ const inputCloudflareInitSecrets = async ({ accountId, bucketName, apiToken, acc
 	}, { onCancel: () => process.exit(1) });
 };
 //#endregion
-//#region iac/index.ts
+//#region iac/configTemplate.ts
 const getConfigScaffold = (build) => {
 	return (0, _hot_updater_cli_tools.createHotUpdaterConfigScaffoldFromBuilder)(new _hot_updater_cli_tools.ConfigBuilder().setBuildType(build).setStorage({
 		imports: [{
@@ -12142,6 +11425,8 @@ const getConfigScaffold = (build) => {
   })`
 	}));
 };
+//#endregion
+//#region iac/index.ts
 const SOURCE_TEMPLATE = `// add this to your App.tsx
 import { HotUpdater } from "@hot-updater/react-native";
 
@@ -12162,7 +11447,8 @@ export default App;`;
 const deployWorker = async (apiToken, accountId, { credentialSource, d1DatabaseId, d1DatabaseName, nonInteractive, r2BucketName, workerName }) => {
 	const cwd = (0, _hot_updater_cli_tools.getCwd)();
 	const cloudflarePackagePath = require.resolve("@hot-updater/cloudflare/package.json", { paths: [cwd] });
-	const { tmpDir, removeTmpDir } = await (0, _hot_updater_cli_tools.copyDirToTmp)(path.default.dirname(cloudflarePackagePath));
+	const cloudflarePackageRoot = path.default.dirname(cloudflarePackagePath);
+	const { tmpDir, removeTmpDir } = await (0, _hot_updater_cli_tools.copyDirToTmp)(cloudflarePackageRoot);
 	const workerRoot = path.default.join(tmpDir, "worker");
 	try {
 		const wranglerConfig = JSON.parse(await fs_promises.default.readFile(path.default.join(workerRoot, "wrangler.json"), "utf-8"));
@@ -12432,13 +11718,16 @@ const runInit = async ({ build, envFile }) => {
 		for await (const resultPage of page.iterPages()) for (const result of resultPage.result) rows.push(...result.results ?? []);
 		return rows;
 	};
-	if (!createD1Database) assertCloudflareInfrastructureCanInitialize((await queryD1(`
+	if (!createD1Database) {
+		const tables = await queryD1(`
       SELECT name
       FROM sqlite_schema
       WHERE type = 'table'
         AND name IN ('bundles', 'release_catalogs')
       ORDER BY name
-    `)).flatMap(({ name }) => typeof name === "string" ? [name] : []), d1DatabaseName);
+    `);
+		assertCloudflareInfrastructureCanInitialize(tables.flatMap(({ name }) => typeof name === "string" ? [name] : []), d1DatabaseName);
+	}
 	const workerScripts = await runCloudflareApiRequest({
 		request: () => cf.workers.scripts.list({ account_id: accountId }),
 		source: infrastructureCredentialSource
@@ -12465,13 +11754,14 @@ const runInit = async ({ build, envFile }) => {
 		secretAccessKey,
 		workerName
 	};
+	const persistCredentialInputs = await (0, _hot_updater_cli_tools.confirmInitInputPersistence)({
+		existingEnv: managedEnv,
+		inputs: resolvedInputs,
+		nonInteractive,
+		provider: initProvider
+	});
 	await (0, _hot_updater_cli_tools.makeEnv)({ ...(0, _hot_updater_cli_tools.getInitProviderEnvVars)({
-		includeConsentInputs: await (0, _hot_updater_cli_tools.confirmInitInputPersistence)({
-			existingEnv: managedEnv,
-			inputs: resolvedInputs,
-			nonInteractive,
-			provider: initProvider
-		}),
+		includeConsentInputs: persistCredentialInputs,
 		inputs: resolvedInputs,
 		provider: initProvider
 	}) });
@@ -12532,27 +11822,27 @@ const runInit = async ({ build, envFile }) => {
 		r2BucketName: selectedBucketName,
 		workerName
 	});
-	const databasePlugin = d1Database({
+	const database = d1Database({
 		accountId,
 		cloudflareApiToken: apiToken,
 		databaseId: selectedD1DatabaseId
 	});
 	let apiKey;
 	try {
-		apiKey = (await (0, _hot_updater_server.provisionApiKey)({
-			apiKeys: databasePlugin.models.apiKeys,
+		apiKey = (await (0, _hot_updater_server_db.createDatabasePluginApis)(database, plugins).apiKeys.provision({
 			existingApiKey: initInputEnv.HOT_UPDATER_API_KEY,
 			name: "Cloudflare init"
 		})).apiKey;
 		await (0, _hot_updater_cli_tools.makeEnv)({ HOT_UPDATER_API_KEY: apiKey });
 	} finally {
-		await databasePlugin.dispose?.();
+		await database.dispose?.();
 	}
 	const configWriteResult = await (0, _hot_updater_cli_tools.writeHotUpdaterConfig)(getConfigScaffold(build));
 	_hot_updater_cli_tools.p.log.success("Generated '.env.hotupdater' file with Cloudflare settings.");
 	if (configWriteResult.status === "created") _hot_updater_cli_tools.p.log.success("Generated 'hot-updater.config.ts' file with Cloudflare settings.");
 	else if (configWriteResult.status === "merged") _hot_updater_cli_tools.p.log.success("Updated 'hot-updater.config.ts' file with Cloudflare settings.");
 	else _hot_updater_cli_tools.p.log.warn(`Kept existing 'hot-updater.config.ts' unchanged: ${configWriteResult.reason}`);
+	await (0, _hot_updater_cli_tools.generateHotUpdaterPlugins)("@hot-updater/cloudflare");
 	if (subdomains.subdomain) _hot_updater_cli_tools.p.note((0, _hot_updater_cli_tools.transformTemplate)(SOURCE_TEMPLATE, {
 		apiKey: JSON.stringify(apiKey),
 		source: `https://${workerName}.${subdomains.subdomain}.workers.dev`