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

package/dist/worker/index.mjs

@@ -1,360 +1,928 @@
-import { signToken, verifyJwtSignedUrl } from "@hot-updater/js";
-import { DEFAULT_ROLLOUT_COHORT_COUNT, NIL_UUID, getAssetBaseStorageUri, getBundlePatches, getManifestFileHash, getManifestStorageUri, stripBundleArtifactMetadata } from "@hot-updater/core";
-import { calculatePagination, createDatabasePlugin, createRuntimeStoragePlugin, decodeStorageObjectKey, filterCompatibleAppVersions, resolveUpdateInfoFromBundles } from "@hot-updater/plugin-core";
-//#region src/cloudflareWorkerDatabase.ts
-const buildJsonEachInClause = (columnName, values, params) => {
-	if (values.length === 0) return "1 = 0";
-	params.push(JSON.stringify(values));
-	return `${columnName} IN (SELECT value FROM json_each(?))`;
-};
-function buildWhereClause(conditions) {
-	if (!conditions) return {
-		sql: "",
-		params: []
-	};
-	const clauses = [];
-	const params = [];
-	if (conditions.channel) {
-		clauses.push("channel = ?");
-		params.push(conditions.channel);
-	}
-	if (conditions.platform) {
-		clauses.push("platform = ?");
-		params.push(conditions.platform);
+import { createDatabasePlugin, createStorageDownloadUrl, createStorageKeyBuilder, createStoragePlugin, createStorageUri, isDatabaseMetadataObject, parseStorageUri } from "@hot-updater/plugin-core";
+import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+//#region src/d1Rows.ts
+var InvalidD1RowError = class extends Error {
+	name = "InvalidD1RowError";
+	model;
+	constructor(model) {
+		super(`D1 returned an invalid ${model} row`);
+		this.model = model;
 	}
-	if (conditions.enabled !== void 0) {
-		clauses.push("enabled = ?");
-		params.push(conditions.enabled ? 1 : 0);
+};
+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;
 	}
-	if (conditions.id?.in) clauses.push(buildJsonEachInClause("id", conditions.id.in, params));
-	if (conditions.id?.eq) {
-		clauses.push("id = ?");
-		params.push(conditions.id.eq);
+};
+const metadata = (row) => {
+	const value = jsonValue(row["metadata"], "bundles");
+	if (!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);
 	}
-	if (conditions.id?.gt) {
-		clauses.push("id > ?");
-		params.push(conditions.id.gt);
+}
+//#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]
+		};
 	}
-	if (conditions.id?.gte) {
-		clauses.push("id >= ?");
-		params.push(conditions.id.gte);
+	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);
 	}
-	if (conditions.id?.lt) {
-		clauses.push("id < ?");
-		params.push(conditions.id.lt);
+};
+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);
 	}
-	if (conditions.id?.lte) {
-		clauses.push("id <= ?");
-		params.push(conditions.id.lte);
+	return {
+		sql: ` WHERE ${sql}`,
+		params
+	};
+};
+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;
 	}
-	if (conditions.targetAppVersionNotNull) clauses.push("target_app_version IS NOT NULL");
-	if (conditions.targetAppVersion !== void 0) if (conditions.targetAppVersion === null) clauses.push("target_app_version IS NULL");
-	else {
-		clauses.push("target_app_version = ?");
-		params.push(conditions.targetAppVersion);
+};
+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));
 	}
-	if (conditions.targetAppVersionIn) clauses.push(buildJsonEachInClause("target_app_version", conditions.targetAppVersionIn, params));
-	if (conditions.fingerprintHash !== void 0) if (conditions.fingerprintHash === null) clauses.push("fingerprint_hash IS NULL");
-	else {
-		clauses.push("fingerprint_hash = ?");
-		params.push(conditions.fingerprintHash);
+};
+//#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.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "",
+		sql: clauses.join(" AND ") || "1",
 		params
 	};
-}
-function parseTargetCohorts(value) {
-	if (!value) return null;
-	if (Array.isArray(value)) return value.filter((item) => typeof item === "string");
-	if (typeof value === "string") try {
-		const parsed = JSON.parse(value);
-		if (Array.isArray(parsed)) return parsed.filter((item) => typeof item === "string");
-	} catch {
-		return null;
+};
+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 parseMetadata = (value) => {
-	if (!value) return void 0;
-	if (typeof value === "string") try {
-		return parseMetadata(JSON.parse(value));
-	} catch {
-		return;
+};
+const isExpectationConflictError = (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;
 	}
-	return typeof value === "object" && !Array.isArray(value) ? value : void 0;
-};
-const buildBundlePatchId = (bundleId, baseBundleId) => `${bundleId}:${baseBundleId}`;
-const bundleToPatchRows = (bundle) => getBundlePatches(bundle).map((patch, index) => ({
-	id: buildBundlePatchId(bundle.id, patch.baseBundleId),
-	bundle_id: bundle.id,
-	base_bundle_id: patch.baseBundleId,
-	base_file_hash: patch.baseFileHash,
-	patch_file_hash: patch.patchFileHash,
-	patch_storage_uri: patch.patchStorageUri,
-	order_index: index
-}));
-function transformRowToBundle(row, patchRows = []) {
-	const rawMetadata = parseMetadata(row.metadata);
-	const patches = patchRows.slice().sort((left, right) => (left.order_index ?? 0) - (right.order_index ?? 0) || left.base_bundle_id.localeCompare(right.base_bundle_id)).map((patch) => ({
-		baseBundleId: patch.base_bundle_id,
-		baseFileHash: patch.base_file_hash,
-		patchFileHash: patch.patch_file_hash,
-		patchStorageUri: patch.patch_storage_uri
-	}));
-	const primaryPatch = patches[0] ?? null;
+	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 {
-		id: row.id,
-		channel: row.channel,
-		enabled: Boolean(row.enabled),
-		shouldForceUpdate: Boolean(row.should_force_update),
-		fileHash: row.file_hash,
-		gitCommitHash: row.git_commit_hash,
-		message: row.message,
-		platform: row.platform,
-		targetAppVersion: row.target_app_version,
-		storageUri: row.storage_uri,
-		fingerprintHash: row.fingerprint_hash,
-		metadata: stripBundleArtifactMetadata(rawMetadata),
-		manifestStorageUri: row.manifest_storage_uri ?? null,
-		manifestFileHash: row.manifest_file_hash ?? null,
-		assetBaseStorageUri: row.asset_base_storage_uri ?? null,
-		patches,
-		patchBaseBundleId: primaryPatch?.baseBundleId ?? null,
-		patchBaseFileHash: primaryPatch?.baseFileHash ?? null,
-		patchFileHash: primaryPatch?.patchFileHash ?? null,
-		patchStorageUri: primaryPatch?.patchStorageUri ?? null,
-		rolloutCohortCount: row.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-		targetCohorts: parseTargetCohorts(row.target_cohorts)
+		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 resolveDbFromContext = (context) => {
-	const db = context?.env?.DB;
-	if (!db) throw new Error("d1WorkerDatabase requires env.DB in the hot updater context.");
-	return db;
-};
-const d1WorkerDatabase = () => createDatabasePlugin({
-	name: "d1WorkerDatabase",
-	factory: (config) => {
-		const queryAll = async (sql, params = [], context) => {
-			return (await config.getDb(context).prepare(sql).bind(...params).all()).results ?? [];
-		};
-		const queryFirst = async (sql, params = [], context) => {
-			return await config.getDb(context).prepare(sql).bind(...params).first() ?? null;
-		};
-		const getPatchMap = async (bundleIds, context) => {
-			const patchMap = /* @__PURE__ */ new Map();
-			if (bundleIds.length === 0) return patchMap;
-			const rows = await queryAll(`
-            SELECT *
-            FROM bundle_patches
-            WHERE bundle_id IN (SELECT value FROM json_each(?))
-            ORDER BY order_index ASC, base_bundle_id ASC
-          `, [JSON.stringify(bundleIds)], context);
-			for (const row of rows) {
-				const current = patchMap.get(row.bundle_id) ?? [];
-				current.push(row);
-				patchMap.set(row.bundle_id, current);
-			}
-			return patchMap;
-		};
-		const queryBundlesForUpdateInfo = async (conditions, context) => {
-			const { sql: whereClause, params } = buildWhereClause(conditions);
-			const rows = await queryAll(`
-            SELECT * FROM bundles
-            ${whereClause}
-          `, params, context);
-			const patchMap = await getPatchMap(rows.map((row) => row.id), context);
-			return rows.map((row) => transformRowToBundle(row, patchMap.get(row.id)));
+};
+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]
 		};
-		const getTargetAppVersionsForUpdateInfo = async ({ platform, channel, minBundleId }, context) => {
-			return (await queryAll(`
-            SELECT target_app_version
-            FROM bundles
-            WHERE channel = ?
-              AND platform = ?
-              AND enabled = 1
-              AND id >= ?
-              AND target_app_version IS NOT NULL
-            GROUP BY target_app_version
-          `, [
-				channel,
-				platform,
-				minBundleId
-			], context)).map((row) => row.target_app_version);
+		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]
 		};
-		return {
-			async getUpdateInfo(args, context) {
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? NIL_UUID;
-				if (args._updateStrategy === "appVersion") {
-					const compatibleAppVersions = filterCompatibleAppVersions(await getTargetAppVersionsForUpdateInfo({
-						platform: args.platform,
-						channel,
-						minBundleId
-					}, context), args.appVersion);
-					const bundles = compatibleAppVersions.length > 0 ? await queryBundlesForUpdateInfo({
-						enabled: true,
-						platform: args.platform,
-						channel,
-						id: { gte: minBundleId },
-						targetAppVersionIn: compatibleAppVersions
-					}, context) : [];
-					return resolveUpdateInfoFromBundles({
-						args: {
-							...args,
-							channel,
-							minBundleId
-						},
-						bundles,
-						context
-					});
-				}
-				const bundles = await queryBundlesForUpdateInfo({
-					enabled: true,
-					platform: args.platform,
-					channel,
-					id: { gte: minBundleId },
-					fingerprintHash: args.fingerprintHash
-				}, context);
-				return resolveUpdateInfoFromBundles({
-					args: {
-						...args,
-						channel,
-						minBundleId
-					},
-					bundles,
-					context
+		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])
 				});
-			},
-			async getBundleById(bundleId, context) {
-				const [row, patchMap] = await Promise.all([queryFirst("SELECT * FROM bundles WHERE id = ? LIMIT 1", [bundleId], context), getPatchMap([bundleId], context)]);
-				return row ? transformRowToBundle(row, patchMap.get(bundleId)) : null;
-			},
-			async getBundles(options, context) {
-				const { where, limit, orderBy } = options;
-				const offset = ("offset" in options ? options.offset : void 0) ?? 0;
-				const { sql: whereClause, params } = buildWhereClause(where);
-				const orderSql = orderBy?.direction === "asc" ? "ORDER BY id ASC" : "ORDER BY id DESC";
-				const total = (await queryAll(`SELECT COUNT(*) as total FROM bundles${whereClause}`, params, context))[0]?.total ?? 0;
-				const rows = await queryAll(`SELECT * FROM bundles${whereClause} ${orderSql} LIMIT ? OFFSET ?`, [
-					...params,
-					limit,
-					offset
-				], context);
-				const patchMap = await getPatchMap(rows.map((row) => row.id), context);
-				return {
-					data: rows.map((row) => transformRowToBundle(row, patchMap.get(row.id))),
-					pagination: calculatePagination(total, {
-						limit,
-						offset
-					})
-				};
-			},
-			async getChannels(context) {
-				return (await queryAll("SELECT channel FROM bundles GROUP BY channel", [], context)).map((row) => row.channel);
-			},
-			async commitBundle({ changedSets }, context) {
-				if (changedSets.length === 0) return;
-				const db = config.getDb(context);
-				for (const operation of changedSets) {
-					if (operation.operation === "delete") {
-						await db.prepare("DELETE FROM bundle_patches WHERE bundle_id = ?").bind(operation.data.id).run();
-						await db.prepare("DELETE FROM bundle_patches WHERE base_bundle_id = ?").bind(operation.data.id).run();
-						await db.prepare("DELETE FROM bundles WHERE id = ?").bind(operation.data.id).run();
-						continue;
-					}
-					const bundle = operation.data;
-					await db.prepare(`
-                INSERT OR REPLACE INTO bundles (
-                  id,
-                  channel,
-                  enabled,
-                  should_force_update,
-                  file_hash,
-                  git_commit_hash,
-                  message,
-                  platform,
-                  target_app_version,
-                  storage_uri,
-                  fingerprint_hash,
-                  metadata,
-                  manifest_storage_uri,
-                  manifest_file_hash,
-                  asset_base_storage_uri,
-                  rollout_cohort_count,
-                  target_cohorts
-                )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-              `).bind(bundle.id, bundle.channel, bundle.enabled ? 1 : 0, bundle.shouldForceUpdate ? 1 : 0, bundle.fileHash, bundle.gitCommitHash || null, bundle.message || null, bundle.platform, bundle.targetAppVersion, bundle.storageUri, bundle.fingerprintHash, JSON.stringify(stripBundleArtifactMetadata(bundle.metadata) ?? {}), getManifestStorageUri(bundle), getManifestFileHash(bundle), getAssetBaseStorageUri(bundle), bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT, bundle.targetCohorts ? JSON.stringify(bundle.targetCohorts) : null).run();
-					await db.prepare("DELETE FROM bundle_patches WHERE bundle_id = ?").bind(bundle.id).run();
-					const patchRows = bundleToPatchRows(bundle);
-					for (const patchRow of patchRows) await db.prepare(`
-                  INSERT OR REPLACE INTO bundle_patches (
-                    id,
-                    bundle_id,
-                    base_bundle_id,
-                    base_file_hash,
-                    patch_file_hash,
-                    patch_storage_uri,
-                    order_index
-                  )
-                  VALUES (?, ?, ?, ?, ?, ?, ?)
-                `).bind(patchRow.id, patchRow.bundle_id, patchRow.base_bundle_id, patchRow.base_file_hash, patchRow.patch_file_hash, patchRow.patch_storage_uri, patchRow.order_index ?? 0).run();
-				}
 			}
-		};
+		}
+		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);
 	}
-})({ getDb: resolveDbFromContext });
-//#endregion
-//#region src/r2WorkerStorage.ts
-const resolveContextValue = async (value, context) => {
-	return typeof value === "function" ? await value(context) : value;
+	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 resolveJwtSecretFromContext = (context) => {
-	const jwtSecret = context?.env?.JWT_SECRET;
-	if (!jwtSecret) throw new Error("r2WorkerStorage requires env.JWT_SECRET in the hot updater context.");
-	return jwtSecret;
+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 resolveR2BucketFromContext = (context) => {
-	const bucket = context?.env?.BUCKET;
-	if (!bucket) throw new Error("r2WorkerStorage requires env.BUCKET in the hot updater context.");
-	return bucket;
+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 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"
+				}
+			};
+		}
+	}
+});
+//#endregion
+//#region src/worker/d1Database.ts
+const d1Database = (database) => {
+	const adapter = createDatabasePluginAdapter("d1Database", createD1Implementation({
+		async query(sql, params) {
+			return (await database.prepare(sql).bind(...params).all()).results ?? [];
+		},
+		async batch(statements) {
+			return (await database.batch(statements.map(({ sql, params }) => database.prepare(sql).bind(...params)))).map(({ results }) => results ?? []);
+		}
+	}));
+	return createDatabasePlugin({
+		name: "d1Database",
+		models: adapter.models,
+		commit: adapter.commit,
+		...adapter.dispose ? { dispose: adapter.dispose } : {}
+	});
 };
-const createPublicObjectPath = (storageUrl) => `${storageUrl.host}${storageUrl.pathname}`;
-const createR2ObjectKey = (storageUrl) => decodeStorageObjectKey(storageUrl.pathname.replace(/^\/+/, ""));
+//#endregion
+//#region src/r2WorkerStorage.ts
 const r2WorkerStorage = (config) => {
-	return createRuntimeStoragePlugin({
-		name: "r2WorkerStorage",
-		supportedProtocol: "r2",
-		factory: (config) => ({
-			async readText(storageUri, context) {
-				const storageUrl = new URL(storageUri);
-				if (storageUrl.protocol !== "r2:") throw new Error("Invalid R2 storage URI protocol");
-				const bucket = resolveR2BucketFromContext(context);
-				const key = createR2ObjectKey(storageUrl);
-				const object = await bucket.get(key);
-				if (!object) return null;
-				return object.text();
-			},
-			async getDownloadUrl(storageUri, context) {
-				const storageUrl = new URL(storageUri);
-				if (storageUrl.protocol !== "r2:") throw new Error("Invalid R2 storage URI protocol");
-				const key = createPublicObjectPath(storageUrl);
-				const [jwtSecret, publicBaseUrl] = await Promise.all([resolveContextValue(config.jwtSecret ?? resolveJwtSecretFromContext, context), resolveContextValue(config.publicBaseUrl, context)]);
-				const token = await signToken(key, jwtSecret);
-				const url = new URL(publicBaseUrl);
-				url.pathname = key;
-				url.search = "";
-				url.searchParams.set("token", token);
-				return { fileUrl: url.toString() };
+	const getStorageKey = createStorageKeyBuilder(config.basePath);
+	const getDownloadUrl = createStorageDownloadUrl(config.downloadUrlSigningKey);
+	const parseAndValidate = (storageUri) => {
+		const parsed = parseStorageUri(storageUri, "r2");
+		if (parsed.bucket !== config.bucketName) throw new Error(`Bucket name mismatch: expected "${config.bucketName}", but found "${parsed.bucket}".`);
+		return parsed;
+	};
+	return createStoragePlugin({
+		name: "r2Storage",
+		protocol: "r2",
+		async put({ key, body, contentLength, contentType }) {
+			const storageKey = getStorageKey(key);
+			const uploadOptions = { httpMetadata: {
+				contentType,
+				cacheControl: "max-age=31536000"
+			} };
+			if (contentLength === void 0) {
+				const bufferedBody = new Uint8Array(await new Response(body).arrayBuffer());
+				await config.bucket.put(storageKey, bufferedBody, uploadOptions);
+			} else {
+				const fixedLengthBody = new FixedLengthStream(contentLength);
+				await Promise.all([body.pipeTo(fixedLengthBody.writable), config.bucket.put(storageKey, fixedLengthBody.readable, uploadOptions)]);
 			}
-		})
-	})(config);
+			return { storageUri: createStorageUri({
+				protocol: "r2",
+				bucket: config.bucketName,
+				key: storageKey
+			}) };
+		},
+		async get({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			const object = await config.bucket.get(key);
+			if (!object) return { response: null };
+			const headers = new Headers();
+			object.writeHttpMetadata(headers);
+			headers.set("etag", object.httpEtag);
+			headers.set("content-length", String(object.size));
+			return { response: new Response(object.body, { headers }) };
+		},
+		async getDownloadUrl({ storageUri }) {
+			parseAndValidate(storageUri);
+			return getDownloadUrl({ storageUri });
+		},
+		async exists({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			return { exists: await config.bucket.head(key) !== null };
+		},
+		async delete({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			await config.bucket.delete(key);
+			return { deleted: true };
+		}
+	});
 };
 //#endregion
-//#region src/worker/index.ts
-const d1Database = () => d1WorkerDatabase();
-const r2Storage = (config) => r2WorkerStorage(config);
-//#endregion
-export { d1Database, r2Storage, verifyJwtSignedUrl };
+export { d1Database, r2WorkerStorage as r2Storage };