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

package/dist/index.mjs

@@ -1,17 +1,17 @@
-import { createHash } from "node:crypto";
+import { CreateTableCommand, DescribeTableCommand, DescribeTimeToLiveCommand, DynamoDBClient, UpdateTimeToLiveCommand, waitUntilTableExists } from "@aws-sdk/client-dynamodb";
+import { createEngineDatabase, createKvAdapter, createStorageAdapter, createStorageDownloadUrl, createStorageKeyBuilder, createStorageUri, migrateCoreSchema, parseStorageUri } from "@hot-updater/plugin-core";
 import { CloudFrontClient, CreateInvalidationCommand, GetInvalidationCommand } from "@aws-sdk/client-cloudfront";
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { BatchGetCommand, DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, ScanCommand, TransactWriteCommand } from "@aws-sdk/lib-dynamodb";
-import { createDatabasePlugin, createStorageDownloadUrl, createStorageKeyBuilder, createStoragePlugin, createStorageUri, isDatabaseMetadataObject, isInsightsMovementEvent, parseStorageUri } from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+import { BatchGetCommand, BatchWriteCommand, DynamoDBDocumentClient, QueryCommand, TransactWriteCommand } from "@aws-sdk/lib-dynamodb";
 import { SSM } from "@aws-sdk/client-ssm";
 import { getSignedUrl } from "@aws-sdk/cloudfront-signer";
 import { DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, S3Client } from "@aws-sdk/client-s3";
 import { Upload } from "@aws-sdk/lib-storage";
+import { apiKeys } from "@hot-updater/server/plugins/api-keys";
+import { insights } from "@hot-updater/server/plugins/insights";
 //#region src/cloudFrontInvalidation.ts
 const DEFAULT_POLL_INTERVAL_MS = 2e3;
 const DEFAULT_TIMEOUT_MS = 3e5;
-const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const sleep$1 = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 const invalidateCloudFront = async (client, distributionId, paths, options) => {
 	if (paths.length === 0) return;
 	const response = await client.send(new CreateInvalidationCommand({
@@ -29,7 +29,7 @@ const invalidateCloudFront = async (client, distributionId, paths, options) => {
 	if (!invalidationId) throw new Error("CloudFront invalidation response is missing Invalidation.Id");
 	const deadline = Date.now() + DEFAULT_TIMEOUT_MS;
 	while (Date.now() < deadline) {
-		await sleep(DEFAULT_POLL_INTERVAL_MS);
+		await sleep$1(DEFAULT_POLL_INTERVAL_MS);
 		if ((await client.send(new GetInvalidationCommand({
 			DistributionId: distributionId,
 			Id: invalidationId
@@ -37,1971 +37,328 @@ const invalidateCloudFront = async (client, distributionId, paths, options) => {
 	}
 	throw new Error(`Timed out waiting for CloudFront invalidation ${invalidationId}.`);
 };
-//#endregion
-//#region src/dynamoDB.ts
-const DYNAMODB_MAX_METADATA_ITEM_BYTES = 8192;
-const DYNAMODB_MAX_CATALOG_ITEM_BYTES = 409600;
-var DynamoDBMetadataItemSizeError = class extends Error {
-	byteLength;
-	name = "DynamoDBMetadataItemSizeError";
-	constructor(byteLength) {
-		super(`DynamoDB metadata item is ${byteLength} bytes; maximum is ${DYNAMODB_MAX_METADATA_ITEM_BYTES}`);
-		this.byteLength = byteLength;
-	}
-};
-const boundedDynamoDBMetadataItem = (item) => {
-	const byteLength = new TextEncoder().encode(JSON.stringify(item)).byteLength;
-	if (byteLength > 8192) throw new DynamoDBMetadataItemSizeError(byteLength);
-	return item;
-};
-var DynamoDBCatalogItemSizeError = class extends Error {
-	byteLength;
-	name = "DynamoDBCatalogItemSizeError";
-	constructor(byteLength) {
-		super(`DynamoDB catalog item is ${byteLength} bytes; maximum is ${DYNAMODB_MAX_CATALOG_ITEM_BYTES}`);
-		this.byteLength = byteLength;
-	}
-};
-const boundedDynamoDBCatalogItem = (item) => {
-	const byteLength = new TextEncoder().encode(JSON.stringify(item)).byteLength;
-	if (byteLength > 409600) throw new DynamoDBCatalogItemSizeError(byteLength);
-	return item;
-};
-const DYNAMODB_CHANNEL_PARTITION = "channels";
-const DYNAMODB_CHANNEL_NAME_PARTITION = "_hot-updater#channel-names";
-var DynamoDBStoredItemError = class extends Error {
-	name = "DynamoDBStoredItemError";
-	constructor() {
-		super("DynamoDB contains an invalid Hot Updater row");
-	}
-};
-const field = (value, name) => Reflect.get(value, name);
-const isNullableString = (value) => value === null || typeof value === "string";
-const isByteSize = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-const withLegacyArchiveByteSize = (value) => typeof value === "object" && value !== null && field(value, "archive_byte_size") === void 0 ? {
-	...value,
-	archive_byte_size: 0
-} : value;
-const isBundleRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && typeof field(value, "file_hash") === "string" && isNullableString(field(value, "git_commit_hash")) && typeof field(value, "storage_uri") === "string" && isByteSize(field(value, "archive_byte_size")) && isDatabaseMetadataObject(field(value, "metadata")) && isNullableString(field(value, "manifest_storage_uri")) && isNullableString(field(value, "manifest_file_hash")) && isNullableString(field(value, "asset_base_storage_uri"));
-const isPatchRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "bundle_id") === "string" && typeof field(value, "base_bundle_id") === "string" && typeof field(value, "base_file_hash") === "string" && typeof field(value, "patch_file_hash") === "string" && typeof field(value, "patch_storage_uri") === "string" && isByteSize(field(value, "byte_size")) && typeof field(value, "order_index") === "number";
-const isChannelRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "name") === "string";
-const isReleaseRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "revision") === "number" && typeof field(value, "scope_key") === "string" && typeof field(value, "channel_id") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && (field(value, "kind") === "BUNDLE" || field(value, "kind") === "EMBEDDED") && isNullableString(field(value, "bundle_id")) && (field(value, "strategy") === "APP_VERSION" || field(value, "strategy") === "FINGERPRINT") && isNullableString(field(value, "target_app_version")) && isNullableString(field(value, "fingerprint_hash")) && typeof field(value, "enabled") === "boolean" && typeof field(value, "should_force_update") === "boolean" && isNullableString(field(value, "message")) && typeof field(value, "rollout_cohort_count") === "number" && Array.isArray(field(value, "target_cohorts")) && field(value, "target_cohorts").every((cohort) => typeof cohort === "string") && (field(value, "operation") === "DEPLOY" || field(value, "operation") === "PROMOTE" || field(value, "operation") === "ROLLBACK") && isNullableString(field(value, "source_release_id")) && typeof field(value, "created_at_ms") === "number" && typeof field(value, "updated_at_ms") === "number";
-const isReleaseCatalogRow = (value) => typeof value === "object" && value !== null && typeof field(value, "scope_key") === "string" && typeof field(value, "catalog_id") === "string" && (field(value, "strategy") === "APP_VERSION" || field(value, "strategy") === "FINGERPRINT") && typeof field(value, "channel_id") === "string" && typeof field(value, "channel_key") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && isNullableString(field(value, "fingerprint_hash")) && typeof field(value, "generation") === "number" && typeof field(value, "payload") === "string" && typeof field(value, "catalog_hash") === "string" && typeof field(value, "byte_size") === "number" && typeof field(value, "is_tombstone") === "boolean" && typeof field(value, "updated_at_ms") === "number";
-const parseDynamoDBItem = (value) => {
-	const pk = value.pk;
-	const sk = value.sk;
-	const version = value.version;
-	const relationCount = value.relation_count;
-	const ownedPatchCount = value.owned_patch_count;
-	const gsi1pk = value.gsi1pk;
-	const gsi1sk = value.gsi1sk;
-	const row = pk === "bundles" ? withLegacyArchiveByteSize(value.row) : value.row;
-	if (typeof sk !== "string" || typeof version !== "number") throw new DynamoDBStoredItemError();
-	if (pk === "channels" && typeof value.reference_count === "number" && isChannelRow(row)) return {
-		pk,
-		sk,
-		version,
-		reference_count: value.reference_count,
-		row
-	};
-	if (typeof pk === "string" && pk.startsWith("release-scope#") && isReleaseRow(row)) return {
-		pk,
-		sk,
-		version,
-		row
-	};
-	if (pk === "release_catalogs" && isReleaseCatalogRow(row)) return {
-		pk,
-		sk,
-		version,
-		row
-	};
-	if (pk === "bundles" && isBundleRow(row)) {
-		if (typeof relationCount !== "number" || typeof ownedPatchCount !== "number") throw new DynamoDBStoredItemError();
-		return {
-			pk,
-			sk,
-			version,
-			relation_count: relationCount,
-			owned_patch_count: ownedPatchCount,
-			row
-		};
-	}
-	if (pk === "bundle_patches" && typeof gsi1pk === "string" && typeof gsi1sk === "string" && isPatchRow(row)) return {
-		pk,
-		sk,
-		version,
-		gsi1pk,
-		gsi1sk,
-		row
-	};
-	throw new DynamoDBStoredItemError();
-};
-const patchOwnerPartition = (bundleId) => `patch-owner#${bundleId}`;
-const patchOrderKey = (row) => `${row.order_index.toString().padStart(10, "0")}#${row.id}`;
-const toDynamoDBBundleItem = (row, version = 1, relationCount = 0, ownedPatchCount = 0) => ({
-	pk: "bundles",
-	sk: row.id,
-	version,
-	relation_count: relationCount,
-	owned_patch_count: ownedPatchCount,
-	row
-});
-const toDynamoDBPatchItem = (row, version = 1) => {
-	const orderKey = patchOrderKey(row);
+/**
+* The update-check routes' CloudFront invalidation: `invalidate` purges their
+* cached copies and `destroy` releases the client; undefined without a
+* distribution. A failed invalidation only warns, so the write that changed
+* the routes still succeeds.
+*/
+const createUpdateRouteInvalidation = ({ apiBasePath = "/release-catalogs", cloudfrontDistributionId, shouldWaitForInvalidation = false, credentials, region }) => {
+	if (!cloudfrontDistributionId) return void 0;
+	const client = new CloudFrontClient({
+		credentials,
+		region
+	});
 	return {
-		pk: "bundle_patches",
-		sk: row.id,
-		version,
-		gsi1pk: patchOwnerPartition(row.bundle_id),
-		gsi1sk: orderKey,
-		row
-	};
-};
-const toDynamoDBChannelItem = (row, version = 1, referenceCount = 0) => ({
-	pk: DYNAMODB_CHANNEL_PARTITION,
-	sk: row.id,
-	version,
-	reference_count: referenceCount,
-	row
-});
-const releaseScopePartition = (scopeKey) => `release-scope#${scopeKey}`;
-const toDynamoDBReleaseItem = (row, version = 1) => ({
-	pk: releaseScopePartition(row.scope_key),
-	sk: row.id,
-	version,
-	row
-});
-const toDynamoDBReleaseCatalogItem = (row, version = 1) => ({
-	pk: "release_catalogs",
-	sk: row.scope_key,
-	version,
-	row
-});
-const itemKey = (model, id) => ({
-	pk: model,
-	sk: id
-});
-const exactDynamoDBId = (where) => {
-	if (where?.length !== 1) return void 0;
-	const condition = where[0];
-	if (Reflect.get(condition, "field") !== "id" || (Reflect.get(condition, "operator") ?? "eq") !== "eq" || Reflect.get(condition, "mode") === "insensitive") return;
-	const value = Reflect.get(condition, "value");
-	return typeof value === "string" ? value : void 0;
-};
-const exactDynamoDBPatchOwner = (where) => {
-	const owners = exactDynamoDBPatchOwners(where);
-	return owners?.length === 1 ? owners[0] : void 0;
-};
-const exactDynamoDBPatchOwners = (where) => {
-	if (!where || where.some((condition) => Reflect.get(condition, "connector") === "OR")) return;
-	const ownerConditions = where.filter((condition) => Reflect.get(condition, "field") === "bundle_id");
-	if (ownerConditions.length !== 1) return void 0;
-	const condition = ownerConditions[0];
-	if (Reflect.get(condition, "mode") === "insensitive") return;
-	const operator = Reflect.get(condition, "operator") ?? "eq";
-	const value = Reflect.get(condition, "value");
-	if (operator === "eq") return typeof value === "string" ? [value] : void 0;
-	if (operator === "in" && Array.isArray(value) && value.every((id) => typeof id === "string")) return value;
-};
-const exactDynamoDBBundleIds = (where) => {
-	if (!where || where.some((condition) => Reflect.get(condition, "connector") === "OR")) return;
-	for (const condition of where) {
-		if (Reflect.get(condition, "field") !== "id" || Reflect.get(condition, "mode") === "insensitive") continue;
-		const operator = Reflect.get(condition, "operator") ?? "eq";
-		const value = Reflect.get(condition, "value");
-		if (operator === "eq" && typeof value === "string") return [value];
-		if (operator === "in" && Array.isArray(value) && value.every((id) => typeof id === "string")) return value;
-	}
-};
-const dynamoDBBundlePageStart = (where, direction) => {
-	if ((where ?? []).some((condition) => Reflect.get(condition, "connector") === "OR")) return;
-	let result;
-	for (const condition of where ?? []) {
-		if (Reflect.get(condition, "field") !== "id") continue;
-		const operator = Reflect.get(condition, "operator") ?? "eq";
-		const value = Reflect.get(condition, "value");
-		if (!(direction === "asc" ? operator === "gt" || operator === "gte" : operator === "lt" || operator === "lte") || typeof value !== "string") continue;
-		const inclusive = operator === "gte" || operator === "lte";
-		if (result === void 0 || (direction === "asc" ? value > result.id : value < result.id) || value === result.id && !inclusive) result = {
-			id: value,
-			inclusive
-		};
-	}
-	return result;
-};
-const parseStoredItem = (item) => parseDynamoDBItem(item.pk === "release_catalogs" ? boundedDynamoDBCatalogItem(item) : boundedDynamoDBMetadataItem(item));
-const queryItems = async (store, input) => {
-	let exclusiveStartKey;
-	const items = [];
-	do {
-		const sortCondition = input.minimumSortKey ? " AND #sortKey >= :minimumSortKey" : "";
-		const page = await store.client.send(new QueryCommand({
-			TableName: store.tableName,
-			...input.indexName ? { IndexName: input.indexName } : {},
-			...input.consistentRead ? { ConsistentRead: true } : {},
-			ExclusiveStartKey: exclusiveStartKey,
-			KeyConditionExpression: `#partitionKey = :partition${sortCondition}`,
-			ExpressionAttributeNames: {
-				"#partitionKey": input.indexName ? "gsi1pk" : "pk",
-				...input.minimumSortKey ? { "#sortKey": input.indexName ? "gsi1sk" : "sk" } : {}
-			},
-			ExpressionAttributeValues: {
-				":partition": input.partition,
-				...input.minimumSortKey ? { ":minimumSortKey": input.minimumSortKey } : {}
+		invalidate: async () => {
+			try {
+				await invalidateCloudFront(client, cloudfrontDistributionId, [`${apiBasePath.replace(/\/+$/, "")}/*`], { shouldWait: shouldWaitForInvalidation });
+			} catch (error) {
+				console.warn("[hot-updater/aws] CloudFront invalidation failed; continuing without cache invalidation.", {
+					distributionId: cloudfrontDistributionId,
+					error: error instanceof Error ? error.message : "Unknown error"
+				});
 			}
-		}));
-		const pageItems = (page.Items ?? []).map(parseStoredItem);
-		items.push(...pageItems);
-		exclusiveStartKey = page.LastEvaluatedKey;
-	} while (exclusiveStartKey !== void 0);
-	return items;
-};
-const queryBundleItemsPage = async (store, input) => {
-	if (input.limit === 0) return [];
-	let exclusiveStartKey;
-	const items = [];
-	do {
-		const startOperator = input.start?.inclusive ? input.direction === "asc" ? ">=" : "<=" : input.direction === "asc" ? ">" : "<";
-		const page = await store.client.send(new QueryCommand({
-			TableName: store.tableName,
-			ExclusiveStartKey: exclusiveStartKey,
-			KeyConditionExpression: input.start ? `#pk = :pk AND #sk ${startOperator} :start` : "#pk = :pk",
-			ExpressionAttributeNames: {
-				"#pk": "pk",
-				...input.start ? { "#sk": "sk" } : {}
-			},
-			ExpressionAttributeValues: {
-				":pk": "bundles",
-				...input.start ? { ":start": input.start.id } : {}
-			},
-			Limit: Math.max(input.limit - items.length, 100),
-			ScanIndexForward: input.direction === "asc"
-		}));
-		for (const item of (page.Items ?? []).map(parseStoredItem)) {
-			if (item.pk === "bundles" && input.matches(item.row)) items.push(item);
-			if (items.length === input.limit) return items;
-		}
-		exclusiveStartKey = page.LastEvaluatedKey;
-	} while (exclusiveStartKey !== void 0);
-	return items;
-};
-const loadModelItems = (store, model) => queryItems(store, {
-	partition: model,
-	consistentRead: true
-});
-const loadModelItem = async (store, model, id) => {
-	const { Item } = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: itemKey(model, id),
-		ConsistentRead: true
-	}));
-	return Item === void 0 ? void 0 : parseStoredItem(Item);
-};
-const loadBundleItem = async (store, id) => {
-	const item = await loadModelItem(store, "bundles", id);
-	return item?.pk === "bundles" ? item : void 0;
-};
-const loadPatchItem = async (store, id) => {
-	const item = await loadModelItem(store, "bundle_patches", id);
-	return item?.pk === "bundle_patches" ? item : void 0;
-};
-const loadChannelItem = async (store, id) => {
-	const item = await loadModelItem(store, DYNAMODB_CHANNEL_PARTITION, id);
-	return item?.pk === "channels" ? item : void 0;
-};
-const loadBundleItems = async (store) => {
-	return (await loadModelItems(store, "bundles")).filter((item) => item.pk === "bundles");
-};
-const loadPatchItems = async (store) => {
-	return (await loadModelItems(store, "bundle_patches")).filter((item) => item.pk === "bundle_patches");
-};
-const loadChannelItems = async (store) => {
-	return (await loadModelItems(store, DYNAMODB_CHANNEL_PARTITION)).filter((item) => item.pk === DYNAMODB_CHANNEL_PARTITION);
-};
-const DYNAMODB_RELEASE_ID_PARTITION = "_hot-updater#release-scope-by-id";
-const releaseLocatorItem = (row) => ({
-	pk: DYNAMODB_RELEASE_ID_PARTITION,
-	sk: row.id,
-	scope_key: row.scope_key
-});
-const loadReleaseItem = async (store, id) => {
-	const locator = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: {
-			pk: DYNAMODB_RELEASE_ID_PARTITION,
-			sk: id
 		},
-		ConsistentRead: true
-	}));
-	if (locator.Item === void 0) return void 0;
-	const scopeKey = locator.Item.scope_key;
-	if (typeof scopeKey !== "string") throw new DynamoDBStoredItemError();
-	const result = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: {
-			pk: releaseScopePartition(scopeKey),
-			sk: id
-		},
-		ConsistentRead: true
-	}));
-	if (result.Item === void 0) throw new DynamoDBStoredItemError();
-	const item = parseStoredItem(result.Item);
-	if (!isReleaseRow(item.row) || item.sk !== id) throw new DynamoDBStoredItemError();
-	return item;
-};
-const loadReleaseItemsByScope = async (store, scopeKey) => (await queryItems(store, {
-	partition: releaseScopePartition(scopeKey),
-	consistentRead: true
-})).filter((item) => item.pk === releaseScopePartition(scopeKey) && isReleaseRow(item.row));
-const loadReleaseItems = async (store) => {
-	let exclusiveStartKey;
-	const items = [];
-	do {
-		const page = await store.client.send(new ScanCommand({
-			TableName: store.tableName,
-			ExclusiveStartKey: exclusiveStartKey,
-			ConsistentRead: true,
-			FilterExpression: "begins_with(#pk, :prefix)",
-			ExpressionAttributeNames: { "#pk": "pk" },
-			ExpressionAttributeValues: { ":prefix": "release-scope#" }
-		}));
-		for (const value of page.Items ?? []) {
-			const item = parseStoredItem(value);
-			if (isReleaseRow(item.row)) items.push(item);
-		}
-		exclusiveStartKey = page.LastEvaluatedKey;
-	} while (exclusiveStartKey !== void 0);
-	return items;
-};
-const loadReleaseCatalogItem = async (store, scopeKey) => {
-	const result = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: itemKey("release_catalogs", scopeKey),
-		ConsistentRead: true
-	}));
-	if (result.Item === void 0) return void 0;
-	const item = parseStoredItem(result.Item);
-	return item.pk === "release_catalogs" ? item : void 0;
-};
-const loadReleaseCatalogItems = async (store) => (await queryItems(store, {
-	partition: "release_catalogs",
-	consistentRead: true
-})).filter((item) => item.pk === "release_catalogs");
-const loadChannelByName = async (store, name) => {
-	const { Item } = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: {
-			pk: DYNAMODB_CHANNEL_NAME_PARTITION,
-			sk: name
-		},
-		ConsistentRead: true
-	}));
-	const id = Item?.channel_id;
-	if (Item === void 0) return void 0;
-	if (typeof id !== "string") throw new DynamoDBStoredItemError();
-	const channel = await loadChannelItem(store, id);
-	if (channel === void 0 || channel.row.name !== name) throw new DynamoDBStoredItemError();
-	return channel;
-};
-const insertDynamoDBChannel = async (store, input) => {
-	const existing = await loadChannelByName(store, input.row.name);
-	if (existing !== void 0) return {
-		row: existing.row,
-		inserted: false
+		destroy: () => client.destroy()
 	};
-	const existingId = await loadChannelItem(store, input.row.id);
-	if (existingId !== void 0) {
-		if (existingId.row.name === input.row.name) return {
-			row: existingId.row,
-			inserted: false
-		};
-		throw new DynamoDBStoredItemError();
-	}
-	try {
-		await commitDynamoDBTransaction(store, [{ Put: {
-			TableName: store.tableName,
-			Item: boundedDynamoDBMetadataItem(toDynamoDBChannelItem(input.row)),
-			ConditionExpression: "attribute_not_exists(#pk)",
-			ExpressionAttributeNames: { "#pk": "pk" }
-		} }, { Put: {
-			TableName: store.tableName,
-			Item: {
-				pk: DYNAMODB_CHANNEL_NAME_PARTITION,
-				sk: input.row.name,
-				channel_id: input.row.id
-			},
-			ConditionExpression: "attribute_not_exists(#pk)",
-			ExpressionAttributeNames: { "#pk": "pk" }
-		} }]);
-		return {
-			row: input.row,
-			inserted: true
-		};
-	} catch (error) {
-		const canonical = await loadChannelByName(store, input.row.name);
-		if (canonical !== void 0) return {
-			row: canonical.row,
-			inserted: false
-		};
-		throw error;
-	}
 };
-const deleteDynamoDBChannel = async (store, input) => {
-	const current = await loadChannelItem(store, input.id);
-	if (current === void 0) return {
-		deleted: false,
-		reason: "not_found"
-	};
-	if (current.reference_count !== 0) return {
-		deleted: false,
-		reason: "not_empty"
-	};
-	try {
-		await commitDynamoDBTransaction(store, [{ Delete: {
-			TableName: store.tableName,
-			Key: itemKey(DYNAMODB_CHANNEL_PARTITION, current.sk),
-			ConditionExpression: "#version = :version AND #referenceCount = :zero",
-			ExpressionAttributeNames: {
-				"#version": "version",
-				"#referenceCount": "reference_count"
-			},
-			ExpressionAttributeValues: {
-				":version": current.version,
-				":zero": 0
-			}
-		} }, { Delete: {
-			TableName: store.tableName,
-			Key: {
-				pk: DYNAMODB_CHANNEL_NAME_PARTITION,
-				sk: current.row.name
-			},
-			ConditionExpression: "#channelId = :channelId",
-			ExpressionAttributeNames: { "#channelId": "channel_id" },
-			ExpressionAttributeValues: { ":channelId": current.sk }
-		} }]);
-		return { deleted: true };
-	} catch (error) {
-		const latest = await loadChannelItem(store, input.id);
-		if (latest !== void 0 && latest.reference_count > 0) return {
-			deleted: false,
-			reason: "not_empty"
-		};
-		if (latest === void 0) return {
-			deleted: false,
-			reason: "not_found"
-		};
-		throw error;
-	}
-};
-const queryOwnerPatchIds = async (store, indexName, bundleId) => {
-	return (await queryItems(store, {
-		partition: patchOwnerPartition(bundleId),
-		indexName
-	})).filter((item) => item.pk === "bundle_patches").map(({ sk }) => sk);
-};
-var DynamoDBTransactionLimitError = class extends Error {
-	actionCount;
-	name = "DynamoDBTransactionLimitError";
-	constructor(actionCount) {
-		super(`DynamoDB transaction requires ${actionCount} actions; maximum is 100`);
-		this.actionCount = actionCount;
-	}
-};
-const metadataUpdate = (store, delta) => {
-	const entries = Object.entries(delta).filter(([, value]) => value !== 0);
-	if (entries.length === 0) return void 0;
+//#endregion
+//#region src/dynamoDBStore.ts
+/** DynamoDB's limits: 100 items and 4 MB a transaction, 400 KB an item, and 2,048- and 1,024-byte keys. */
+const DYNAMODB_LIMITS = {
+	items: 100,
+	bytes: 4e6,
+	itemBytes: 4e5,
+	keyBytes: {
+		pk: 2048,
+		sk: 1024
+	}
+};
+/** BatchGetItem takes 100 keys a call, and BatchWriteItem 25 requests. */
+const GET_BATCH = 100;
+const WRITE_BATCH = 25;
+/**
+* The table's TTL attribute: epoch seconds on every item of a row that
+* expires, which DynamoDB deletes for free. No column is named like it.
+*/
+const DYNAMODB_TTL_ATTRIBUTE = "_ttl";
+/** A column named like a key attribute is stored with a leading dot, which no column name has. */
+const attribute = (column) => column === "pk" || column === "sk" ? `.${column}` : column;
+const renamed = (record, rename) => Object.fromEntries(Object.entries(record).map(([name, value]) => [rename(name), value]));
+const ttl = (expiresAt) => expiresAt === void 0 ? {} : { _ttl: Math.ceil(expiresAt / 1e3) };
+const toItem = (key, row, expiresAt) => ({
+	...renamed({
+		...row,
+		...ttl(expiresAt)
+	}, attribute),
+	pk: key.pk,
+	sk: key.sk
+});
+const toRow = ({ pk: _pk, sk: _sk, _ttl, ...item }) => renamed(item, (name) => name.replace(/^\./, ""));
+const idOf = ({ pk, sk }) => JSON.stringify([pk, sk]);
+const nameOf = (error) => error.name;
+const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+/**
+* One transaction item. Its expressions bind every column name and value, so
+* no column clashes with a reserved word; `pk` and `sk` are none.
+*/
+const toTransactItem = (tableName, op) => {
 	const names = {};
 	const values = {};
-	const updates = [];
-	const conditions = [];
-	for (const [model, change] of entries) {
-		const name = model === "bundles" ? "bundles" : "patches";
-		const valueName = model === "bundles" ? "bundle" : "patch";
-		names[`#${name}`] = name;
-		values[`:${valueName}Delta`] = change;
-		updates.push(`#${name} :${valueName}Delta`);
-		if (change < 0) {
-			values[`:${valueName}Removal`] = -change;
-			conditions.push(`#${name} >= :${valueName}Removal`);
-		}
-	}
-	return { Update: {
-		TableName: store.tableName,
-		Key: {
-			pk: "_hot-updater",
-			sk: "limits.metadata"
-		},
-		UpdateExpression: `ADD ${updates.join(", ")}`,
-		...conditions.length > 0 ? { ConditionExpression: conditions.join(" AND ") } : {},
-		ExpressionAttributeNames: names,
-		ExpressionAttributeValues: values
-	} };
-};
-const updateBundleRelation = (store, bundleId, delta, ownedPatchDelta = 0) => {
-	const names = {
-		"#pk": "pk",
-		"#version": "version"
+	const binder = (map, prefix) => (entry) => {
+		const token = `${prefix}${Object.keys(map).length}`;
+		map[token] = entry;
+		return token;
 	};
-	const values = { ":one": 1 };
-	const additions = [];
-	let condition = "attribute_exists(#pk)";
-	let update = "SET #version = #version + :one";
-	if (delta !== 0) {
-		names["#relationCount"] = "relation_count";
-		values[":relationDelta"] = delta;
-		additions.push("#relationCount :relationDelta");
-		if (delta < 0) {
-			values[":relationRemoval"] = -delta;
-			condition += " AND #relationCount >= :relationRemoval";
-		}
-	}
-	if (ownedPatchDelta !== 0) {
-		names["#ownedPatchCount"] = "owned_patch_count";
-		values[":ownedPatchDelta"] = ownedPatchDelta;
-		additions.push("#ownedPatchCount :ownedPatchDelta");
-		if (ownedPatchDelta < 0) {
-			values[":ownedPatchRemoval"] = -ownedPatchDelta;
-			condition += " AND #ownedPatchCount >= :ownedPatchRemoval";
-		}
-	}
-	if (additions.length > 0) update += ` ADD ${additions.join(", ")}`;
-	return { Update: {
-		TableName: store.tableName,
-		Key: itemKey("bundles", bundleId),
-		ConditionExpression: condition,
-		ExpressionAttributeNames: names,
-		ExpressionAttributeValues: values,
-		UpdateExpression: update
-	} };
-};
-const commitDynamoDBTransaction = async (store, actions) => {
-	if (actions.length > 100) throw new DynamoDBTransactionLimitError(actions.length);
-	await store.client.send(new TransactWriteCommand({ TransactItems: [...actions] }));
-};
-const DYNAMODB_BATCH_GET_ATTEMPTS = 5;
-const DYNAMODB_BATCH_GET_BASE_DELAY_MS = 25;
-var DynamoDBBatchGetExhaustedError = class extends Error {
-	unprocessedKeyCount;
-	name = "DynamoDBBatchGetExhaustedError";
-	constructor(unprocessedKeyCount) {
-		super(`DynamoDB did not process ${unprocessedKeyCount} batch-get keys after ${DYNAMODB_BATCH_GET_ATTEMPTS} attempts`);
-		this.unprocessedKeyCount = unprocessedKeyCount;
-	}
-};
-const waitBeforeRetry = (attempt) => new Promise((resolve) => setTimeout(resolve, DYNAMODB_BATCH_GET_BASE_DELAY_MS * 2 ** attempt));
-const batchGetDynamoDBItems = async (store, keys) => {
-	const items = [];
-	for (let offset = 0; offset < keys.length; offset += 100) {
-		let pending = keys.slice(offset, offset + 100);
-		for (let attempt = 0; attempt < DYNAMODB_BATCH_GET_ATTEMPTS && pending.length > 0; attempt++) {
-			const { Responses, UnprocessedKeys } = await store.client.send(new BatchGetCommand({ RequestItems: { [store.tableName]: {
-				ConsistentRead: true,
-				Keys: pending
-			} } }));
-			items.push(...Responses?.[store.tableName] ?? []);
-			pending = UnprocessedKeys?.[store.tableName]?.Keys ?? [];
-			if (pending.length > 0 && attempt + 1 < DYNAMODB_BATCH_GET_ATTEMPTS) await waitBeforeRetry(attempt);
-		}
-		if (pending.length > 0) throw new DynamoDBBatchGetExhaustedError(pending.length);
-	}
-	return items;
-};
-const parseKeyReadItem = (item) => parseDynamoDBItem(boundedDynamoDBMetadataItem(item));
-const loadBundleItemsById = async (store, ids) => {
-	const uniqueIds = [...new Set(ids)];
-	if (uniqueIds.length === 0) return [];
-	return (await batchGetDynamoDBItems(store, uniqueIds.map((id) => itemKey("bundles", id)))).map(parseKeyReadItem).filter((item) => item.pk === "bundles");
-};
-const loadPatchItemsById = async (store, ids) => {
-	const uniqueIds = [...new Set(ids)];
-	if (uniqueIds.length === 0) return [];
-	return (await batchGetDynamoDBItems(store, uniqueIds.map((id) => itemKey("bundle_patches", id)))).map(parseKeyReadItem).filter((item) => item.pk === "bundle_patches");
-};
-const loadMetadataCount = async (store, model) => {
-	if (model !== "bundles" && model !== "bundle_patches") return void 0;
-	const field = model === "bundles" ? "bundles" : "patches";
-	const { Item } = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: {
-			pk: "_hot-updater",
-			sk: "limits.metadata"
-		},
-		ConsistentRead: true,
-		ProjectionExpression: "#count",
-		ExpressionAttributeNames: { "#count": field }
-	}));
-	const count = Item?.[field];
-	return typeof count === "number" && Number.isSafeInteger(count) && count >= 0 ? count : void 0;
-};
-var DynamoDBPatchIndexConsistencyError = class extends Error {
-	bundleId;
-	expectedCount;
-	name = "DynamoDBPatchIndexConsistencyError";
-	constructor(bundleId, expectedCount) {
-		super(`DynamoDB patch index did not converge to ${expectedCount} rows for bundle "${bundleId}"`);
-		this.bundleId = bundleId;
-		this.expectedCount = expectedCount;
-	}
-};
-const waitForIndex = (attempt) => new Promise((resolve) => setTimeout(resolve, 20 * (attempt + 1)));
-const queryCompleteOwnerPatches = async (store, indexName, bundleId) => {
-	const owner = await loadBundleItem(store, bundleId);
-	if (!owner || owner.owned_patch_count === 0) return [];
-	for (let attempt = 0; attempt < 3; attempt++) {
-		const patchIds = await queryOwnerPatchIds(store, indexName, bundleId);
-		const patchIdSet = new Set(patchIds);
-		const patches = (await loadPatchItemsById(store, patchIds)).filter(({ row }) => row.bundle_id === bundleId);
-		if (patchIds.length === owner.owned_patch_count && patchIdSet.size === owner.owned_patch_count && patches.length === owner.owned_patch_count && patches.every(({ sk }) => patchIdSet.has(sk))) return patches.map(({ row }) => row).sort((left, right) => left.order_index - right.order_index || left.id.localeCompare(right.id));
-		if (attempt < 2) await waitForIndex(attempt);
-	}
-	throw new DynamoDBPatchIndexConsistencyError(bundleId, owner.owned_patch_count);
-};
-const queryCompleteOwnersPatches = async (store, indexName, bundleIds) => {
-	const owners = (await loadBundleItemsById(store, bundleIds)).filter(({ owned_patch_count }) => owned_patch_count > 0);
-	const firstOwner = owners[0];
-	if (!firstOwner) return [];
-	let failedOwner = firstOwner;
-	for (let attempt = 0; attempt < 3; attempt++) {
-		const candidateIdsByOwner = await Promise.all(owners.map(({ sk }) => queryOwnerPatchIds(store, indexName, sk)));
-		const candidateIds = candidateIdsByOwner.flat();
-		const patches = await loadPatchItemsById(store, candidateIds);
-		const patchesById = new Map(patches.map((patch) => [patch.sk, patch]));
-		const mismatchedOwner = owners.find((owner, ownerIndex) => {
-			const ids = candidateIdsByOwner[ownerIndex] ?? [];
-			const uniqueIds = new Set(ids);
-			return ids.length !== owner.owned_patch_count || uniqueIds.size !== owner.owned_patch_count || ids.some((id) => patchesById.get(id)?.row.bundle_id !== owner.sk);
-		});
-		if (!mismatchedOwner) return patches.map(({ row }) => row);
-		failedOwner = mismatchedOwner;
-		if (attempt < 2) await waitForIndex(attempt);
-	}
-	throw new DynamoDBPatchIndexConsistencyError(failedOwner.sk, failedOwner.owned_patch_count);
-};
-const createDynamoDBBundlePatchTable = (store, indexName) => ({ findByBundleIds: (bundleIds) => bundleIds.length === 0 ? Promise.resolve([]) : queryCompleteOwnersPatches(store, indexName, bundleIds) });
-const compare = (left, right) => {
-	if (typeof left === "number" && typeof right === "number") return left - right;
-	if (left == null) return right == null ? 0 : -1;
-	if (right == null) return 1;
-	return JSON.stringify(left).localeCompare(JSON.stringify(right));
-};
-const compareString = (actual, expected, mode, predicate) => {
-	if (typeof actual !== "string") return false;
-	return mode === "insensitive" ? predicate(actual.toLocaleLowerCase(), expected.toLocaleLowerCase()) : predicate(actual, expected);
-};
-const matchesCondition = (row, condition) => {
-	const actual = Reflect.get(row, condition.field);
-	const expected = Reflect.get(condition, "value");
-	switch (Reflect.get(condition, "operator") ?? "eq") {
-		case "eq": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value === query) : actual === expected;
-		case "ne":
-			if (actual == null) return false;
-			return typeof expected === "string" ? !compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value === query) : actual !== expected;
-		case "gt": return actual != null && compare(actual, expected) > 0;
-		case "gte": return actual != null && compare(actual, expected) >= 0;
-		case "lt": return actual != null && compare(actual, expected) < 0;
-		case "lte": return actual != null && compare(actual, expected) <= 0;
-		case "in": return Array.isArray(expected) && expected.some((candidate) => candidate === actual);
-		case "not_in": return Array.isArray(expected) && (expected.length === 0 || actual != null && expected.every((candidate) => candidate !== actual));
-		case "contains": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.includes(query)) : false;
-		case "starts_with": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.startsWith(query)) : false;
-		case "ends_with": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.endsWith(query)) : false;
-		default: return false;
-	}
-};
-const matchesDynamoDBWhere = (row, where) => {
-	if (!where || where.length === 0) return true;
-	let result = matchesCondition(row, where[0]);
-	for (const condition of where.slice(1)) {
-		const current = matchesCondition(row, condition);
-		result = condition.connector === "OR" ? result || current : result && current;
-	}
-	return result;
-};
-const compareRows = (left, right, orderBy) => {
-	for (const clause of orderBy) {
-		const leftValue = Reflect.get(left, clause.field);
-		const rightValue = Reflect.get(right, clause.field);
-		if (leftValue == null || rightValue == null) {
-			if (leftValue == null && rightValue == null) continue;
-			const nulls = clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
-			const order = leftValue == null ? -1 : 1;
-			return nulls === "first" ? order : -order;
-		}
-		const order = compare(leftValue, rightValue);
-		if (order !== 0) return clause.direction === "asc" ? order : -order;
-	}
-	return 0;
-};
-const distinctKey = (row, distinctOn) => JSON.stringify(distinctOn.fields.map((field) => Reflect.get(row, field)));
-const queryDynamoDBRows = (rows, input) => {
-	const filtered = rows.filter((row) => matchesDynamoDBWhere(row, input.where));
-	const orderBy = input.orderBy;
-	const ordered = orderBy ? filtered.toSorted((left, right) => compareRows(left, right, orderBy)) : filtered;
-	const distinctOn = input.distinctOn;
-	const distinct = distinctOn ? (() => {
-		const seen = /* @__PURE__ */ new Set();
-		return ordered.filter((row) => {
-			const key = distinctKey(row, distinctOn);
-			if (seen.has(key)) return false;
-			seen.add(key);
-			return true;
-		});
-	})() : ordered;
-	const offset = input.offset ?? 0;
-	return distinct.slice(offset, offset + (input.limit ?? 100));
-};
-const countDistinctDynamoDBRows = (rows, fields) => {
-	if (fields === void 0) return rows.length;
-	return new Set(rows.map((row) => JSON.stringify(fields.map((field) => Reflect.get(row, field))))).size;
-};
-const createDynamoDBBundle = async (store, row) => {
-	const counter = metadataUpdate(store, { bundles: 1 });
-	if (!counter) return;
-	await commitDynamoDBTransaction(store, [counter, { Put: {
-		TableName: store.tableName,
-		Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row)),
-		ConditionExpression: "attribute_not_exists(#pk)",
-		ExpressionAttributeNames: { "#pk": "pk" }
-	} }]);
-};
-const createDynamoDBPatch = async (store, row) => {
-	const bundleIds = [.../* @__PURE__ */ new Set([row.bundle_id, row.base_bundle_id])];
-	const counter = metadataUpdate(store, { bundle_patches: 1 });
-	if (!counter) return;
-	await commitDynamoDBTransaction(store, [
-		counter,
-		...bundleIds.map((bundleId) => updateBundleRelation(store, bundleId, 1, bundleId === row.bundle_id ? 1 : 0)),
-		{ Put: {
-			TableName: store.tableName,
-			Item: boundedDynamoDBMetadataItem(toDynamoDBPatchItem(row)),
-			ConditionExpression: "attribute_not_exists(#pk)",
-			ExpressionAttributeNames: { "#pk": "pk" }
-		} }
-	]);
-};
-const replaceDynamoDBBundle = async (store, current, row) => {
-	await store.client.send(new PutCommand({
-		TableName: store.tableName,
-		Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row, current.version + 1, current.relation_count, current.owned_patch_count)),
-		ConditionExpression: "#version = :currentVersion",
-		ExpressionAttributeNames: { "#version": "version" },
-		ExpressionAttributeValues: { ":currentVersion": current.version }
-	}));
-};
-const deleteAction = (store, item) => ({ Delete: {
-	TableName: store.tableName,
-	Key: {
-		pk: item.pk,
-		sk: item.sk
-	},
-	ConditionExpression: "#version = :currentVersion",
-	ExpressionAttributeNames: { "#version": "version" },
-	ExpressionAttributeValues: { ":currentVersion": item.version }
-} });
-const deleteDynamoDBPatch = async (store, item) => {
-	const counter = metadataUpdate(store, { bundle_patches: -1 });
-	if (!counter) return;
-	const bundleIds = [.../* @__PURE__ */ new Set([item.row.bundle_id, item.row.base_bundle_id])];
-	await commitDynamoDBTransaction(store, [
-		counter,
-		...bundleIds.map((id) => updateBundleRelation(store, id, -1, id === item.row.bundle_id ? -1 : 0)),
-		deleteAction(store, item)
-	]);
-};
-const deleteBundle = async (store, bundle, patches) => {
-	const counter = metadataUpdate(store, {
-		bundles: -1,
-		bundle_patches: -patches.length
+	const name = binder(names, "#n");
+	const value = binder(values, ":v");
+	const { condition } = op;
+	const guard = condition === void 0 ? void 0 : "v" in condition ? `${name("_v")} = ${value(condition.v)}` : `${condition.exists ? "attribute_exists" : "attribute_not_exists"}(pk)`;
+	const item = (fields) => ({
+		TableName: tableName,
+		ConditionExpression: guard,
+		...fields,
+		ExpressionAttributeNames: Object.keys(names).length ? names : void 0,
+		ExpressionAttributeValues: Object.keys(values).length ? values : void 0
 	});
-	if (!counter) return;
-	const otherEndpointCounts = /* @__PURE__ */ new Map();
-	for (const { row } of patches) for (const id of /* @__PURE__ */ new Set([row.bundle_id, row.base_bundle_id])) {
-		if (id === bundle.sk) continue;
-		const current = otherEndpointCounts.get(id) ?? {
-			owned: 0,
-			relations: 0
-		};
-		otherEndpointCounts.set(id, {
-			owned: current.owned + (id === row.bundle_id ? 1 : 0),
-			relations: current.relations + 1
-		});
-	}
-	await commitDynamoDBTransaction(store, [
-		counter,
-		...[...otherEndpointCounts].map(([id, count]) => updateBundleRelation(store, id, -count.relations, -count.owned)),
-		...patches.map((patch) => deleteAction(store, patch)),
-		deleteAction(store, bundle)
-	]);
-};
-const deleteDynamoDBBundles = async (store, bundles, allPatches) => {
-	let patches = [...allPatches];
-	const versionIncrements = /* @__PURE__ */ new Map();
-	for (const originalBundle of bundles) {
-		const bundle = {
-			...originalBundle,
-			version: originalBundle.version + (versionIncrements.get(originalBundle.sk) ?? 0)
-		};
-		const related = patches.filter(({ row }) => row.bundle_id === bundle.sk || row.base_bundle_id === bundle.sk);
-		await deleteBundle(store, bundle, related);
-		const updatedBundleIds = new Set(related.flatMap(({ row }) => [row.bundle_id, row.base_bundle_id]));
-		updatedBundleIds.delete(bundle.sk);
-		for (const id of updatedBundleIds) versionIncrements.set(id, (versionIncrements.get(id) ?? 0) + 1);
-		const removedPatchIds = new Set(related.map(({ sk }) => sk));
-		patches = patches.filter(({ sk }) => !removedPatchIds.has(sk));
-	}
-};
-var DynamoDBUnsupportedModelError = class extends Error {
-	name = "DynamoDBUnsupportedModelError";
-	constructor() {
-		super("DynamoDB received an unsupported database model");
-	}
-};
-const distinctFields = (fields) => fields;
-const exactDynamoDBField = (where, fieldName) => {
-	const conditions = (where ?? []).filter((condition) => Reflect.get(condition, "field") === fieldName);
-	if (conditions.length !== 1) return void 0;
-	const condition = conditions[0];
-	if ((Reflect.get(condition, "operator") ?? "eq") !== "eq" || Reflect.get(condition, "mode") === "insensitive") return;
-	const value = Reflect.get(condition, "value");
-	return typeof value === "string" ? value : void 0;
-};
-const createDynamoDBCrud = (store, updateIndexName) => ({
-	recordInsights: (input) => recordDynamoDBInsightsEvent(store, input),
-	async create(input) {
-		switch (input.model) {
-			case "bundles":
-				await createDynamoDBBundle(store, input.data);
-				return input.data;
-			case "bundle_patches":
-				await createDynamoDBPatch(store, input.data);
-				return input.data;
-			case "releases": {
-				const channel = await loadChannelItem(store, input.data.channel_id);
-				if (channel === void 0) throw new DynamoDBStoredItemError();
-				await commitDynamoDBTransaction(store, [
-					updateChannelReferenceCount(store, channel, 1),
-					{ Put: {
-						TableName: store.tableName,
-						Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(input.data)),
-						ConditionExpression: "attribute_not_exists(#pk)",
-						ExpressionAttributeNames: { "#pk": "pk" }
-					} },
-					{ Put: {
-						TableName: store.tableName,
-						Item: releaseLocatorItem(input.data),
-						ConditionExpression: "attribute_not_exists(#pk)",
-						ExpressionAttributeNames: { "#pk": "pk" }
-					} }
-				]);
-				return input.data;
-			}
-			case "release_catalogs":
-				await store.client.send(new PutCommand({
-					TableName: store.tableName,
-					Item: boundedDynamoDBCatalogItem(toDynamoDBReleaseCatalogItem(input.data)),
-					ConditionExpression: "attribute_not_exists(#pk)",
-					ExpressionAttributeNames: { "#pk": "pk" }
-				}));
-				return input.data;
-			case "channels": return (await insertDynamoDBChannel(store, {
-				row: input.data,
-				onConflict: "returnExisting"
-			})).row;
-		}
-		throw new DynamoDBUnsupportedModelError();
-	},
-	async update(input) {
-		if (input.model === "releases") {
-			const id = exactDynamoDBId(input.where);
-			if (id === void 0) throw new DynamoDBUnsupportedModelError();
-			const current = await loadReleaseItem(store, id);
-			if (current === void 0) return null;
-			const updated = {
-				...current.row,
-				...input.update
-			};
-			const nextPartition = releaseScopePartition(updated.scope_key);
-			const moved = current.pk !== nextPartition;
-			await commitDynamoDBTransaction(store, [
-				...moved ? [{ Delete: {
-					TableName: store.tableName,
-					Key: {
-						pk: current.pk,
-						sk: current.sk
-					},
-					ConditionExpression: "#version = :version",
-					ExpressionAttributeNames: { "#version": "version" },
-					ExpressionAttributeValues: { ":version": current.version }
-				} }] : [],
-				{ Put: {
-					TableName: store.tableName,
-					Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(updated, current.version + 1)),
-					ConditionExpression: moved ? "attribute_not_exists(#pk)" : "#version = :version",
-					ExpressionAttributeNames: moved ? { "#pk": "pk" } : { "#version": "version" },
-					...moved ? {} : { ExpressionAttributeValues: { ":version": current.version } }
-				} },
-				{ Put: {
-					TableName: store.tableName,
-					Item: releaseLocatorItem(updated),
-					ConditionExpression: "#scopeKey = :scopeKey",
-					ExpressionAttributeNames: { "#scopeKey": "scope_key" },
-					ExpressionAttributeValues: { ":scopeKey": current.row.scope_key }
-				} }
-			]);
-			return updated;
-		}
-		if (input.model === "release_catalogs") {
-			const scopeKey = exactDynamoDBField(input.where, "scope_key");
-			if (scopeKey === void 0) throw new DynamoDBUnsupportedModelError();
-			const current = await loadReleaseCatalogItem(store, scopeKey);
-			if (current === void 0) return null;
-			const updated = {
-				...current.row,
-				...input.update
-			};
-			await store.client.send(new PutCommand({
-				TableName: store.tableName,
-				Item: boundedDynamoDBCatalogItem(toDynamoDBReleaseCatalogItem(updated, current.version + 1)),
-				ConditionExpression: "#version = :version",
-				ExpressionAttributeNames: { "#version": "version" },
-				ExpressionAttributeValues: { ":version": current.version }
-			}));
-			return updated;
-		}
-		if (input.model !== "bundles") throw new DynamoDBUnsupportedModelError();
-		const id = exactDynamoDBId(input.where);
-		const current = id === void 0 ? (await loadBundleItems(store)).find(({ row }) => matchesDynamoDBWhere(row, input.where)) : await loadBundleItem(store, id);
-		if (!current) return null;
-		const updated = {
-			...current.row,
-			...input.update
-		};
-		await replaceDynamoDBBundle(store, current, updated);
-		return updated;
-	},
-	async delete(input) {
-		if (input.model === "channels") {
-			const id = exactDynamoDBId(input.where);
-			if (id !== void 0) await deleteDynamoDBChannel(store, { id });
-			return;
-		}
-		if (input.model === "bundle_patches") {
-			const items = (await loadPatchItems(store)).filter(({ row }) => matchesDynamoDBWhere(row, input.where));
-			for (const item of items) await deleteDynamoDBPatch(store, item);
-			return;
-		}
-		if (input.model === "releases") {
-			const items = (await loadReleaseItems(store)).filter(({ row }) => matchesDynamoDBWhere(row, input.where));
-			for (const item of items) {
-				const channel = await loadChannelItem(store, item.row.channel_id);
-				if (channel === void 0) throw new DynamoDBStoredItemError();
-				await commitDynamoDBTransaction(store, [
-					updateChannelReferenceCount(store, channel, -1),
-					deleteAction(store, item),
-					{ Delete: {
-						TableName: store.tableName,
-						Key: {
-							pk: DYNAMODB_RELEASE_ID_PARTITION,
-							sk: item.sk
-						},
-						ConditionExpression: "#scopeKey = :scopeKey",
-						ExpressionAttributeNames: { "#scopeKey": "scope_key" },
-						ExpressionAttributeValues: { ":scopeKey": item.row.scope_key }
-					} }
-				]);
-			}
-			return;
-		}
-		if (input.model !== "bundles") throw new DynamoDBUnsupportedModelError();
-		const bundleItems = (await loadBundleItems(store)).filter(({ row }) => matchesDynamoDBWhere(row, input.where));
-		if (bundleItems.length === 0) return;
-		await deleteDynamoDBBundles(store, bundleItems, await loadPatchItems(store));
-	},
-	async count(input) {
-		if ((input.where === void 0 || input.where.length === 0) && input.distinct === void 0) {
-			const count = await loadMetadataCount(store, input.model);
-			if (count !== void 0) return count;
-		}
-		switch (input.model) {
-			case "bundles": {
-				const rows = (await loadBundleItems(store)).map(({ row }) => row).filter((row) => matchesDynamoDBWhere(row, input.where));
-				return countDistinctDynamoDBRows(rows, distinctFields(input.distinct));
-			}
-			case "bundle_patches": {
-				const ownerId = exactDynamoDBPatchOwner(input.where);
-				const rows = (ownerId ? await queryCompleteOwnerPatches(store, updateIndexName, ownerId) : (await loadPatchItems(store)).map(({ row }) => row)).filter((row) => matchesDynamoDBWhere(row, input.where));
-				return countDistinctDynamoDBRows(rows, distinctFields(input.distinct));
-			}
-			case "releases": {
-				const scopeKey = exactDynamoDBField(input.where, "scope_key");
-				const rows = (scopeKey === void 0 ? await loadReleaseItems(store) : await loadReleaseItemsByScope(store, scopeKey)).map(({ row }) => row).filter((row) => matchesDynamoDBWhere(row, input.where));
-				return countDistinctDynamoDBRows(rows, distinctFields(input.distinct));
-			}
-		}
-		throw new DynamoDBUnsupportedModelError();
-	},
-	async findOne(input) {
-		const id = exactDynamoDBId(input.where);
-		switch (input.model) {
-			case "bundles":
-				if (id !== void 0) return (await loadBundleItem(store, id))?.row ?? null;
-				return (await loadBundleItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
-			case "bundle_patches":
-				if (id !== void 0) return (await loadPatchItem(store, id))?.row ?? null;
-				{
-					const ownerId = exactDynamoDBPatchOwner(input.where);
-					if (ownerId === void 0) break;
-					return (await queryCompleteOwnerPatches(store, updateIndexName, ownerId)).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
-				}
-			case "channels":
-				if (id !== void 0) return (await loadChannelItem(store, id))?.row ?? null;
-				return (await loadChannelItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
-			case "releases":
-				if (id !== void 0) return (await loadReleaseItem(store, id))?.row ?? null;
-				{
-					const scopeKey = exactDynamoDBField(input.where, "scope_key");
-					return (scopeKey === void 0 ? await loadReleaseItems(store) : await loadReleaseItemsByScope(store, scopeKey)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
-				}
-			case "release_catalogs": {
-				const scopeKey = exactDynamoDBField(input.where, "scope_key");
-				if (scopeKey !== void 0) return (await loadReleaseCatalogItem(store, scopeKey))?.row ?? null;
-				return (await loadReleaseCatalogItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
-			}
-		}
-		if (input.model === "bundle_patches") return (await loadPatchItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
-		throw new DynamoDBUnsupportedModelError();
-	},
-	async findMany(input) {
-		if (input.limit === 0) return [];
-		switch (input.model) {
-			case "bundles": {
-				const ids = exactDynamoDBBundleIds(input.where);
-				if (ids !== void 0) return queryDynamoDBRows((await loadBundleItemsById(store, ids)).map(({ row }) => row), input);
-				const orderBy = input.orderBy;
-				const direction = orderBy?.[0]?.direction;
-				if ((input.offset ?? 0) === 0 && input.distinctOn === void 0 && orderBy?.length === 1 && orderBy[0]?.field === "id" && (direction === "asc" || direction === "desc")) return (await queryBundleItemsPage(store, {
-					direction,
-					limit: input.limit ?? 100,
-					matches: (row) => matchesDynamoDBWhere(row, input.where),
-					start: dynamoDBBundlePageStart(input.where, direction)
-				})).map(({ row }) => row);
-				return queryDynamoDBRows((await loadBundleItems(store)).map(({ row }) => row), input);
-			}
-			case "bundle_patches": {
-				const ownerIds = exactDynamoDBPatchOwners(input.where);
-				if (ownerIds !== void 0) {
-					const ownerId = ownerIds.length === 1 ? ownerIds[0] : void 0;
-					return queryDynamoDBRows(ownerId !== void 0 ? await queryCompleteOwnerPatches(store, updateIndexName, ownerId) : await queryCompleteOwnersPatches(store, updateIndexName, ownerIds), input);
-				}
-				return queryDynamoDBRows((await loadPatchItems(store)).map(({ row }) => row), input);
-			}
-			case "channels": return queryDynamoDBRows((await loadChannelItems(store)).map(({ row }) => row), input);
-			case "releases": {
-				const scopeKey = exactDynamoDBField(input.where, "scope_key");
-				return queryDynamoDBRows((scopeKey === void 0 ? await loadReleaseItems(store) : await loadReleaseItemsByScope(store, scopeKey)).map(({ row }) => row), input);
-			}
-			case "release_catalogs": return queryDynamoDBRows((await loadReleaseCatalogItems(store)).map(({ row }) => row), input);
-		}
-		throw new DynamoDBUnsupportedModelError();
-	},
-	insertChannel: (input) => insertDynamoDBChannel(store, input),
-	deleteChannel: (input) => deleteDynamoDBChannel(store, input)
-});
-var DynamoDBDuplicatePatchError = class extends Error {
-	patchId;
-	name = "DynamoDBDuplicatePatchError";
-	constructor(patchId) {
-		super(`DynamoDB bundle mutation contains duplicate patch "${patchId}"`);
-		this.patchId = patchId;
-	}
-};
-const putNewBundle = (store, row, relationCount, ownedPatchCount = relationCount) => ({ Put: {
-	TableName: store.tableName,
-	Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row, 1, relationCount, ownedPatchCount)),
-	ConditionExpression: "attribute_not_exists(#pk)",
-	ExpressionAttributeNames: { "#pk": "pk" }
-} });
-const putUpdatedBundle = (store, current, row, relationCount, ownedPatchCount) => ({ Put: {
-	TableName: store.tableName,
-	Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row, current.version + 1, relationCount, ownedPatchCount)),
-	ConditionExpression: "#version = :currentVersion",
-	ExpressionAttributeNames: { "#version": "version" },
-	ExpressionAttributeValues: { ":currentVersion": current.version }
-} });
-const putPatch = (store, row, current) => ({ Put: {
-	TableName: store.tableName,
-	Item: boundedDynamoDBMetadataItem(toDynamoDBPatchItem(row, (current?.version ?? 0) + 1)),
-	ConditionExpression: current ? "#version = :currentVersion" : "attribute_not_exists(#pk)",
-	ExpressionAttributeNames: current ? { "#version": "version" } : { "#pk": "pk" },
-	...current ? { ExpressionAttributeValues: { ":currentVersion": current.version } } : {}
-} });
-const deletePatch = (store, item) => ({ Delete: {
-	TableName: store.tableName,
-	Key: itemKey(item.pk, item.sk),
-	ConditionExpression: "#version = :currentVersion",
-	ExpressionAttributeNames: { "#version": "version" },
-	ExpressionAttributeValues: { ":currentVersion": item.version }
-} });
-var DynamoDBCommitStateError = class extends Error {
-	name = "DynamoDBCommitStateError";
-	constructor(message) {
-		super(message);
-	}
-};
-const rowsEqual = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-const putChannel = (store, row, current, referenceCount) => ({ Put: {
-	TableName: store.tableName,
-	Item: boundedDynamoDBMetadataItem(toDynamoDBChannelItem(row, (current?.version ?? 0) + 1, referenceCount)),
-	ConditionExpression: current ? "#version = :version" : "attribute_not_exists(#pk)",
-	ExpressionAttributeNames: current ? { "#version": "version" } : { "#pk": "pk" },
-	...current ? { ExpressionAttributeValues: { ":version": current.version } } : {}
-} });
-const deleteChannelActions = (store, current) => [{ Delete: {
-	TableName: store.tableName,
-	Key: itemKey(DYNAMODB_CHANNEL_PARTITION, current.sk),
-	ConditionExpression: "#version = :version",
-	ExpressionAttributeNames: { "#version": "version" },
-	ExpressionAttributeValues: { ":version": current.version }
-} }, { Delete: {
-	TableName: store.tableName,
-	Key: {
-		pk: DYNAMODB_CHANNEL_NAME_PARTITION,
-		sk: current.row.name
-	},
-	ConditionExpression: "#channelId = :channelId",
-	ExpressionAttributeNames: { "#channelId": "channel_id" },
-	ExpressionAttributeValues: { ":channelId": current.sk }
-} }];
-const updateChannelReferenceCount = (store, current, delta) => ({ Update: {
-	TableName: store.tableName,
-	Key: itemKey(DYNAMODB_CHANNEL_PARTITION, current.sk),
-	ConditionExpression: "#row.#name = :name" + (delta < 0 ? " AND #referenceCount >= :removal" : ""),
-	UpdateExpression: "SET #version = #version + :one ADD #referenceCount :delta",
-	ExpressionAttributeNames: {
-		"#row": "row",
-		"#name": "name",
-		"#version": "version",
-		"#referenceCount": "reference_count"
-	},
-	ExpressionAttributeValues: {
-		":name": current.row.name,
-		":one": 1,
-		":delta": delta,
-		...delta < 0 ? { ":removal": -delta } : {}
-	}
-} });
-const loadApiKeyByHash = async (store, hash) => {
-	const { Item } = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: {
-			pk: DYNAMODB_API_KEY_HASH_PARTITION,
-			sk: hash
-		},
-		ConsistentRead: true
-	}));
-	if (Item === void 0) return null;
-	const id = Item.api_key_id;
-	if (typeof id !== "string") throw new DynamoDBStoredItemError();
-	return loadApiKey(store, id);
-};
-const compileAndCommitDynamoDBChanges = async (store, input) => {
-	const [originalBundleItems, originalPatchItems, originalChannelItems, originalReleaseItems, originalReleaseCatalogItems] = await Promise.all([
-		loadBundleItems(store),
-		loadPatchItems(store),
-		loadChannelItems(store),
-		loadReleaseItems(store),
-		loadReleaseCatalogItems(store)
-	]);
-	const bundles = new Map(originalBundleItems.map(({ sk, row }) => [sk, row]));
-	const patches = new Map(originalPatchItems.map(({ sk, row }) => [sk, row]));
-	const channels = new Map(originalChannelItems.map(({ sk, row }) => [sk, row]));
-	const channelNames = new Map(originalChannelItems.map(({ sk, row }) => [row.name, sk]));
-	const releases = new Map(originalReleaseItems.map(({ sk, row }) => [sk, row]));
-	const releaseCatalogs = new Map(originalReleaseCatalogItems.map(({ sk, row }) => [sk, row]));
-	const originalApiKeys = /* @__PURE__ */ new Map();
-	const apiKeys = /* @__PURE__ */ new Map();
-	const apiKeyHashes = /* @__PURE__ */ new Map();
-	const rememberApiKey = (value) => {
-		if (value === null || apiKeys.has(value.row.id)) return;
-		originalApiKeys.set(value.row.id, value);
-		apiKeys.set(value.row.id, value);
-		apiKeyHashes.set(value.row.hash, value.row.id);
-	};
-	const requireReleaseReferences = (row) => {
-		if (!channels.has(row.channel_id)) throw new DynamoDBCommitStateError(`Release "${row.id}" references an invalid channel`);
-		if (row.bundle_id !== null) {
-			const bundle = bundles.get(row.bundle_id);
-			if (bundle === void 0 || bundle.platform !== row.platform) throw new DynamoDBCommitStateError(`Release "${row.id}" references an invalid bundle`);
-		}
+	const Key = {
+		pk: op.key.pk,
+		sk: op.key.sk
 	};
-	for (const expectation of input.expectations ?? []) {
-		const actualVersion = expectation.model === "releases" ? releases.get(expectation.id)?.revision ?? null : releaseCatalogs.get(expectation.scopeKey)?.generation ?? null;
-		const expectedVersion = expectation.model === "releases" ? expectation.revision : expectation.generation;
-		if (actualVersion !== expectedVersion) return {
-			committed: false,
-			conflict: {
-				actualVersion,
-				changeIndex: -1,
-				expectedVersion,
-				key: expectation.model === "releases" ? expectation.id : expectation.scopeKey,
-				model: expectation.model,
-				reason: "version_conflict"
-			}
-		};
-	}
-	for (const [changeIndex, change] of input.changes.entries()) switch (change.model) {
-		case "channels":
-			if (change.operation === "insert") {
-				if (channelNames.get(change.row.name) !== void 0) break;
-				if (channels.get(change.row.id) !== void 0) throw new DynamoDBCommitStateError(`Channel id "${change.row.id}" already exists`);
-				channels.set(change.row.id, change.row);
-				channelNames.set(change.row.name, change.row.id);
-			} else {
-				const current = channels.get(change.where.id);
-				if (current === void 0) break;
-				if ([...releases.values()].some(({ channel_id }) => channel_id === change.where.id)) return {
-					committed: false,
-					conflict: {
-						changeIndex,
-						reason: "referenced"
-					}
-				};
-				channels.delete(change.where.id);
-				channelNames.delete(current.name);
-			}
-			break;
-		case "bundles":
-			if (change.operation === "insert") {
-				if (bundles.has(change.row.id)) throw new DynamoDBCommitStateError(`Bundle "${change.row.id}" already exists`);
-				bundles.set(change.row.id, change.row);
-			} else {
-				const current = bundles.get(change.where.id);
-				if (current === void 0) {
-					if (change.operation === "update") return {
-						committed: false,
-						conflict: {
-							changeIndex,
-							reason: "not_found"
-						}
-					};
-					break;
-				}
-				if (change.operation === "update") {
-					const row = {
-						...current,
-						...change.update
-					};
-					bundles.set(row.id, row);
-				} else {
-					if ([...releases.values()].some(({ bundle_id }) => bundle_id === change.where.id)) return {
-						committed: false,
-						conflict: {
-							changeIndex,
-							reason: "referenced"
-						}
-					};
-					bundles.delete(change.where.id);
-					for (const [id, patch] of patches) if (patch.bundle_id === change.where.id || patch.base_bundle_id === change.where.id) patches.delete(id);
-				}
-			}
-			break;
-		case "releases":
-			if (change.operation === "insert") {
-				requireReleaseReferences(change.row);
-				if (releases.has(change.row.id)) throw new DynamoDBCommitStateError(`Release "${change.row.id}" already exists`);
-				releases.set(change.row.id, change.row);
-			} else {
-				const current = releases.get(change.where.id);
-				if (current === void 0) {
-					if (change.operation === "update") return {
-						committed: false,
-						conflict: {
-							changeIndex,
-							reason: "not_found"
-						}
-					};
-					break;
-				}
-				if (change.operation === "update") {
-					const row = {
-						...current,
-						...change.update
-					};
-					requireReleaseReferences(row);
-					releases.set(row.id, row);
-				} else releases.delete(change.where.id);
-			}
-			break;
-		case "releaseCatalogs":
-			if (!channels.has(change.row.channel_id)) throw new DynamoDBCommitStateError(`Release catalog "${change.row.scope_key}" references an invalid channel`);
-			releaseCatalogs.set(change.row.scope_key, change.row);
-			break;
-		case "bundlePatches":
-			if (change.operation === "insert") {
-				if (!bundles.has(change.row.bundle_id) || !bundles.has(change.row.base_bundle_id)) throw new DynamoDBCommitStateError(`Patch "${change.row.id}" references a missing bundle`);
-				if (patches.has(change.row.id)) throw new DynamoDBDuplicatePatchError(change.row.id);
-				patches.set(change.row.id, change.row);
-			} else for (const [id, patch] of patches) if (patch.bundle_id === change.where.bundleId) patches.delete(id);
-			break;
-		case "apiKeys": if (change.operation === "insert") {
-			rememberApiKey(await loadApiKeyByHash(store, change.row.hash));
-			if (apiKeyHashes.has(change.row.hash)) break;
-			rememberApiKey(await loadApiKey(store, change.row.id));
-			if (apiKeys.has(change.row.id)) throw new DynamoDBCommitStateError(`API key id "${change.row.id}" already exists`);
-			const inserted = {
-				row: change.row,
-				version: 1
+	switch (op.type) {
+		case "put": return { Put: item({ Item: toItem(op.key, op.value, op.expiresAt) }) };
+		case "delete": return { Delete: item({ Key }) };
+		case "check": return { ConditionCheck: item({
+			Key,
+			ConditionExpression: guard
+		}) };
+		case "add": {
+			const init = {
+				...op.init,
+				...ttl(op.expiresAt)
 			};
-			apiKeys.set(change.row.id, inserted);
-			apiKeyHashes.set(change.row.hash, change.row.id);
-		} else {
-			rememberApiKey(await loadApiKey(store, change.where.id));
-			const current = apiKeys.get(change.where.id);
-			if (current === void 0) return {
-				committed: false,
-				conflict: {
-					changeIndex,
-					reason: "not_found"
-				}
-			};
-			apiKeys.set(change.where.id, {
-				row: {
-					...current.row,
-					revoked_at_ms: change.update.revokedAtMs
-				},
-				version: current.version
-			});
-		}
-	}
-	const relationCounts = /* @__PURE__ */ new Map();
-	const ownedPatchCounts = /* @__PURE__ */ new Map();
-	for (const patch of patches.values()) {
-		for (const id of /* @__PURE__ */ new Set([patch.bundle_id, patch.base_bundle_id])) relationCounts.set(id, (relationCounts.get(id) ?? 0) + 1);
-		ownedPatchCounts.set(patch.bundle_id, (ownedPatchCounts.get(patch.bundle_id) ?? 0) + 1);
-	}
-	const channelReferenceCounts = /* @__PURE__ */ new Map();
-	for (const release of releases.values()) channelReferenceCounts.set(release.channel_id, (channelReferenceCounts.get(release.channel_id) ?? 0) + 1);
-	const actions = [];
-	const originalChannels = new Map(originalChannelItems.map((item) => [item.sk, item]));
-	for (const original of originalChannelItems) if (!channels.has(original.sk)) actions.push(...deleteChannelActions(store, original));
-	for (const [id, row] of channels) {
-		const original = originalChannels.get(id);
-		const referenceCount = channelReferenceCounts.get(id) ?? 0;
-		if (original === void 0) {
-			actions.push(putChannel(store, row, original, referenceCount));
-			actions.push({ Put: {
-				TableName: store.tableName,
-				Item: {
-					pk: DYNAMODB_CHANNEL_NAME_PARTITION,
-					sk: row.name,
-					channel_id: id
-				},
-				ConditionExpression: "attribute_not_exists(#pk)",
-				ExpressionAttributeNames: { "#pk": "pk" }
-			} });
-		} else {
-			if (!rowsEqual(original.row, row)) throw new DynamoDBCommitStateError(`Channel "${id}" cannot be updated`);
-			const delta = referenceCount - original.reference_count;
-			if (delta !== 0) actions.push(updateChannelReferenceCount(store, original, delta));
-		}
-	}
-	const originalBundles = new Map(originalBundleItems.map((item) => [item.sk, item]));
-	for (const original of originalBundleItems) if (!bundles.has(original.sk)) actions.push(deleteAction(store, original));
-	for (const [id, row] of bundles) {
-		const original = originalBundles.get(id);
-		const relationCount = relationCounts.get(id) ?? 0;
-		const ownedPatchCount = ownedPatchCounts.get(id) ?? 0;
-		if (original === void 0) actions.push(putNewBundle(store, row, relationCount, ownedPatchCount));
-		else if (!rowsEqual(original.row, row)) actions.push(putUpdatedBundle(store, original, row, relationCount, ownedPatchCount));
-		else {
-			const relationDelta = relationCount - original.relation_count;
-			const ownedPatchDelta = ownedPatchCount - original.owned_patch_count;
-			if (relationDelta !== 0 || ownedPatchDelta !== 0) actions.push(updateBundleRelation(store, id, relationDelta, ownedPatchDelta));
-		}
-	}
-	const originalPatches = new Map(originalPatchItems.map((item) => [item.sk, item]));
-	for (const original of originalPatchItems) if (!patches.has(original.sk)) actions.push(deletePatch(store, original));
-	for (const [id, row] of patches) {
-		const original = originalPatches.get(id);
-		if (original === void 0 || !rowsEqual(original.row, row)) actions.push(putPatch(store, row, original));
-	}
-	const originalReleases = new Map(originalReleaseItems.map((item) => [item.sk, item]));
-	for (const original of originalReleaseItems) {
-		if (releases.get(original.sk) !== void 0) continue;
-		actions.push(deleteAction(store, original));
-		actions.push({ Delete: {
-			TableName: store.tableName,
-			Key: {
-				pk: DYNAMODB_RELEASE_ID_PARTITION,
-				sk: original.sk
-			},
-			ConditionExpression: "#scopeKey = :scopeKey",
-			ExpressionAttributeNames: { "#scopeKey": "scope_key" },
-			ExpressionAttributeValues: { ":scopeKey": original.row.scope_key }
-		} });
-	}
-	for (const [id, row] of releases) {
-		const original = originalReleases.get(id);
-		if (original === void 0) {
-			actions.push({ Put: {
-				TableName: store.tableName,
-				Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(row)),
-				ConditionExpression: "attribute_not_exists(#pk)",
-				ExpressionAttributeNames: { "#pk": "pk" }
-			} });
-			actions.push({ Put: {
-				TableName: store.tableName,
-				Item: releaseLocatorItem(row),
-				ConditionExpression: "attribute_not_exists(#pk)",
-				ExpressionAttributeNames: { "#pk": "pk" }
-			} });
-		} else if (!rowsEqual(original.row, row)) {
-			const moved = original.row.scope_key !== row.scope_key;
-			if (moved) actions.push(deleteAction(store, original));
-			actions.push({ Put: {
-				TableName: store.tableName,
-				Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(row, original.version + 1)),
-				ConditionExpression: moved ? "attribute_not_exists(#pk)" : "#version = :version",
-				ExpressionAttributeNames: moved ? { "#pk": "pk" } : { "#version": "version" },
-				...moved ? {} : { ExpressionAttributeValues: { ":version": original.version } }
-			} });
-			if (moved) actions.push({ Put: {
-				TableName: store.tableName,
-				Item: releaseLocatorItem(row),
-				ConditionExpression: "#scopeKey = :scopeKey",
-				ExpressionAttributeNames: { "#scopeKey": "scope_key" },
-				ExpressionAttributeValues: { ":scopeKey": original.row.scope_key }
-			} });
-		}
-	}
-	const originalReleaseCatalogs = new Map(originalReleaseCatalogItems.map((item) => [item.sk, item]));
-	for (const [scopeKey, row] of releaseCatalogs) {
-		const original = originalReleaseCatalogs.get(scopeKey);
-		if (original === void 0 || !rowsEqual(original.row, row)) actions.push({ Put: {
-			TableName: store.tableName,
-			Item: boundedDynamoDBCatalogItem(toDynamoDBReleaseCatalogItem(row, (original?.version ?? 0) + 1)),
-			ConditionExpression: original ? "#version = :version" : "attribute_not_exists(#pk)",
-			ExpressionAttributeNames: original ? { "#version": "version" } : { "#pk": "pk" },
-			...original ? { ExpressionAttributeValues: { ":version": original.version } } : {}
-		} });
-	}
-	const changedReleaseIds = new Set([.../* @__PURE__ */ new Set([...originalReleases.keys(), ...releases.keys()])].filter((id) => {
-		const original = originalReleases.get(id)?.row;
-		const next = releases.get(id);
-		return original === void 0 || next === void 0 || !rowsEqual(original, next);
-	}));
-	const changedCatalogScopes = new Set([...releaseCatalogs].flatMap(([scopeKey, row]) => {
-		const original = originalReleaseCatalogs.get(scopeKey)?.row;
-		return original === void 0 || !rowsEqual(original, row) ? [scopeKey] : [];
-	}));
-	for (const expectation of input.expectations ?? []) {
-		if (expectation.model === "releases" && !changedReleaseIds.has(expectation.id)) {
-			const original = originalReleases.get(expectation.id);
-			actions.push({ ConditionCheck: {
-				TableName: store.tableName,
-				Key: original === void 0 ? {
-					pk: DYNAMODB_RELEASE_ID_PARTITION,
-					sk: expectation.id
-				} : {
-					pk: original.pk,
-					sk: original.sk
-				},
-				ConditionExpression: original === void 0 ? "attribute_not_exists(#pk)" : "#version = :version",
-				ExpressionAttributeNames: original === void 0 ? { "#pk": "pk" } : { "#version": "version" },
-				...original === void 0 ? {} : { ExpressionAttributeValues: { ":version": original.version } }
-			} });
-		}
-		if (expectation.model === "releaseCatalogs" && !changedCatalogScopes.has(expectation.scopeKey)) {
-			const original = originalReleaseCatalogs.get(expectation.scopeKey);
-			actions.push({ ConditionCheck: {
-				TableName: store.tableName,
-				Key: itemKey("release_catalogs", expectation.scopeKey),
-				ConditionExpression: original === void 0 ? "attribute_not_exists(#pk)" : "#version = :version",
-				ExpressionAttributeNames: original === void 0 ? { "#pk": "pk" } : { "#version": "version" },
-				...original === void 0 ? {} : { ExpressionAttributeValues: { ":version": original.version } }
-			} });
+			return { Update: item({
+				Key,
+				UpdateExpression: `SET ${Object.keys({
+					...init,
+					...op.by
+				}).map((column) => {
+					const path = name(attribute(column));
+					const by = op.by[column];
+					if (by === void 0) return `${path} = if_not_exists(${path}, ${value(init[column])})`;
+					return `${path} = if_not_exists(${path}, ${value(Number(init[column] ?? 0))}) + ${value(by)}`;
+				}).join(", ")}`
+			}) };
 		}
 	}
-	const counter = metadataUpdate(store, {
-		bundles: bundles.size - originalBundles.size,
-		bundle_patches: patches.size - originalPatches.size
-	});
-	if (counter !== void 0) actions.push(counter);
-	for (const [id, current] of apiKeys) {
-		const original = originalApiKeys.get(id);
-		if (original !== void 0 && rowsEqual(original.row, current.row)) continue;
-		actions.push({ Put: {
-			TableName: store.tableName,
-			Item: boundedDynamoDBMetadataItem(apiKeyItem(current.row, original === void 0 ? 1 : original.version + 1)),
-			ConditionExpression: original ? "#version = :version" : "attribute_not_exists(#pk)",
-			ExpressionAttributeNames: original ? { "#version": "version" } : { "#pk": "pk" },
-			...original ? { ExpressionAttributeValues: { ":version": original.version } } : {}
-		} });
-		if (original === void 0) actions.push({ Put: {
-			TableName: store.tableName,
-			Item: {
-				pk: DYNAMODB_API_KEY_HASH_PARTITION,
-				sk: current.row.hash,
-				api_key_id: current.row.id
-			},
-			ConditionExpression: "attribute_not_exists(#pk)",
-			ExpressionAttributeNames: { "#pk": "pk" }
-		} });
-	}
-	if (actions.length > 0) await commitDynamoDBTransaction(store, actions);
-	return { committed: true };
 };
-const isDynamoDBTransactionConflict = (error) => typeof error === "object" && error !== null && Reflect.get(error, "name") === "TransactionCanceledException";
-const createDynamoDBCommit = (store) => async (input) => {
-	try {
-		return await compileAndCommitDynamoDBChanges(store, input);
-	} catch (error) {
-		if (!isDynamoDBTransactionConflict(error)) throw error;
-		return compileAndCommitDynamoDBChanges(store, input);
-	}
-};
-const DYNAMODB_INSIGHTS_PARTITION = "bundle_events";
-const DYNAMODB_INSIGHTS_INSTALLATIONS_PARTITION = "_hot-updater#insights-installations";
-const DYNAMODB_INSIGHTS_EVENT_IDS_PARTITION = "_hot-updater#insights-event-ids";
-const DYNAMODB_INSIGHTS_BUNDLE_PREFIX = "_hot-updater#insights-bundle#";
-const DYNAMODB_API_KEY_PARTITION = "api_keys";
-const DYNAMODB_API_KEY_HASH_PARTITION = "_hot-updater#api-key-hashes";
-const DYNAMODB_INSIGHTS_MOVEMENT_PREFIX = "_hot-updater#insights-movement#";
-const DYNAMODB_INSIGHTS_USER_PREFIX = "_hot-updater#insights-user#";
-const DYNAMODB_INSIGHTS_RECORD_ATTEMPTS = 3;
-const hasValidBundleEventShape = (value) => {
-	const type = field(value, "type");
-	const fromBundleId = field(value, "from_bundle_id");
-	const updateStrategy = field(value, "update_strategy");
-	return (type === "UPDATE_APPLIED" || type === "RECOVERED" || type === "RELEASE_ADOPTED") && typeof fromBundleId === "string" && (updateStrategy === "fingerprint" || updateStrategy === "appVersion") || type === "UNCHANGED" && fromBundleId === null && updateStrategy === null;
-};
-const isBundleEventRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "install_id") === "string" && isNullableString(field(value, "from_release_id")) && isNullableString(field(value, "to_release_id")) && typeof field(value, "to_bundle_id") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && typeof field(value, "received_at_ms") === "number" && hasValidBundleEventShape(value);
-const isInsightsInstallationRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "install_id") === "string" && isNullableString(field(value, "user_id")) && isNullableString(field(value, "username")) && typeof field(value, "to_bundle_id") === "string" && (field(value, "type") === "UPDATE_APPLIED" || field(value, "type") === "RECOVERED" || field(value, "type") === "RELEASE_ADOPTED" || field(value, "type") === "UNCHANGED") && (field(value, "platform") === "ios" || field(value, "platform") === "android") && typeof field(value, "app_version") === "string" && typeof field(value, "channel") === "string" && typeof field(value, "cohort") === "string" && typeof field(value, "received_at_ms") === "number";
-const isApiKeyRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "hash") === "string" && typeof field(value, "name") === "string" && typeof field(value, "prefix") === "string" && field(value, "role") === "client" && typeof field(value, "created_at_ms") === "number" && (field(value, "revoked_at_ms") === null || typeof field(value, "revoked_at_ms") === "number");
-const parseOfficialRowItem = (value, partition, isRow) => {
-	if (value.pk !== partition || typeof value.sk !== "string" || typeof value.version !== "number" || !isRow(value.row)) throw new DynamoDBStoredItemError();
+/** Errors, and cancellation reasons, that a retry of the whole write can clear. */
+const TRANSIENT = /* @__PURE__ */ new Set([
+	"TransactionConflict",
+	"ThrottlingError",
+	"ProvisionedThroughputExceeded",
+	"RequestLimitExceeded",
+	"TransactionInProgressException",
+	"ProvisionedThroughputExceededException",
+	"ThrottlingException",
+	"InternalServerError"
+]);
+/** A missing table reads as one to the schema fence, like SQL's 42P01. */
+const missingTable = (error) => {
+	throw nameOf(error) === "ResourceNotFoundException" ? Object.assign(new Error(error.message, { cause: error }), { code: "42P01" }) : error;
+};
+/**
+* The key-value store over one DynamoDB table keyed by `pk` and `sk`, with
+* no secondary index. Reads are strongly consistent; a write is one
+* `TransactWriteItems` with a client request token.
+*/
+const createDynamoDBStore = ({ client, tableName, nativePageSize }) => {
+	const documents = DynamoDBDocumentClient.from(client, { marshallOptions: { removeUndefinedValues: true } });
 	return {
-		row: value.row,
-		version: value.version
-	};
-};
-const timestampSortKey = (timestampMs) => Math.trunc(timestampMs).toString().padStart(16, "0");
-const insightsSortKey = (row) => `${timestampSortKey(row.received_at_ms)}#${row.id}`;
-const insightsMovementPartition = (installId) => `${DYNAMODB_INSIGHTS_MOVEMENT_PREFIX}${installId}`;
-const insightsUserPartition = (userId) => `${DYNAMODB_INSIGHTS_USER_PREFIX}${userId}`;
-const insightsBundlePartition = (filter) => {
-	const scope = JSON.stringify([
-		filter.platform,
-		filter.channel,
-		filter.type,
-		filter.type === "RECOVERED" ? filter.fromBundleId : filter.toBundleId
-	]);
-	return `${DYNAMODB_INSIGHTS_BUNDLE_PREFIX}${createHash("sha256").update(scope, "utf8").digest("hex")}`;
-};
-const toInsightsBundleItem = (row) => row.type === "UNCHANGED" ? null : boundedDynamoDBMetadataItem({
-	pk: insightsBundlePartition({
-		platform: row.platform,
-		channel: row.channel,
-		...row.type === "RECOVERED" ? {
-			type: row.type,
-			fromBundleId: row.from_bundle_id
-		} : {
-			type: row.type,
-			toBundleId: row.to_bundle_id
-		}
-	}),
-	sk: insightsSortKey(row),
-	version: 1,
-	row
-});
-const toInsightsEventItem = (row) => {
-	const orderKey = insightsSortKey(row);
-	return boundedDynamoDBMetadataItem({
-		pk: DYNAMODB_INSIGHTS_PARTITION,
-		sk: orderKey,
-		version: 1,
-		row,
-		...isInsightsMovementEvent(row) ? {
-			gsi1pk: insightsMovementPartition(row.install_id),
-			gsi1sk: orderKey
-		} : {}
-	});
-};
-const toInsightsInstallationItem = (row) => boundedDynamoDBMetadataItem({
-	pk: DYNAMODB_INSIGHTS_INSTALLATIONS_PARTITION,
-	sk: row.install_id,
-	order_key: insightsSortKey(row),
-	version: 1,
-	row
-});
-const toInsightsUserItem = (row) => boundedDynamoDBMetadataItem({
-	pk: insightsUserPartition(row.user_id),
-	sk: row.install_id,
-	order_key: insightsSortKey(row),
-	version: 1,
-	row
-});
-const parseInsightsInstallationItem = (value, partition) => {
-	const row = value.row;
-	if (value.pk !== partition || typeof value.sk !== "string" || typeof value.order_key !== "string" || value.version !== 1 || !isInsightsInstallationRow(row) || value.sk !== row.install_id || value.order_key !== insightsSortKey(row)) throw new DynamoDBStoredItemError();
-	return value;
-};
-const loadInsightsInstallationItem = async (store, installId) => {
-	const { Item } = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: {
-			pk: DYNAMODB_INSIGHTS_INSTALLATIONS_PARTITION,
-			sk: installId
+		id: "dynamoDB",
+		limits: DYNAMODB_LIMITS,
+		async get(keys) {
+			const found = /* @__PURE__ */ new Map();
+			const unique = [...new Map(keys.map((key) => [idOf(key), key])).values()];
+			for (let at = 0; at < unique.length; at += GET_BATCH) {
+				let pending = unique.slice(at, at + GET_BATCH).map(({ pk, sk }) => ({
+					pk,
+					sk
+				}));
+				for (let round = 0; pending.length > 0; round += 1) {
+					if (round > 0) await sleep(2 ** round * 10);
+					const RequestItems = { [tableName]: {
+						Keys: pending,
+						ConsistentRead: true
+					} };
+					const result = await documents.send(new BatchGetCommand({ RequestItems })).catch(missingTable);
+					for (const item of result.Responses?.[tableName] ?? []) found.set(idOf(item), toRow(item));
+					pending = result.UnprocessedKeys?.[tableName]?.Keys ?? [];
+				}
+			}
+			return keys.map((key) => found.get(idOf(key)) ?? null);
 		},
-		ConsistentRead: true
-	}));
-	return Item === void 0 ? null : parseInsightsInstallationItem(Item, DYNAMODB_INSIGHTS_INSTALLATIONS_PARTITION);
-};
-const advancesInsightsInstallation = (row, current) => row.received_at_ms > current.received_at_ms || row.received_at_ms === current.received_at_ms && row.id > current.id;
-const recordDynamoDBInsightsEvent = async (store, { event: row, installation: next }) => {
-	const eventItem = toInsightsEventItem(row);
-	const bundleItem = toInsightsBundleItem(row);
-	const identityKey = {
-		pk: DYNAMODB_INSIGHTS_EVENT_IDS_PARTITION,
-		sk: row.id
-	};
-	for (let attempt = 0; attempt < DYNAMODB_INSIGHTS_RECORD_ATTEMPTS; attempt++) {
-		const { Item: accepted } = await store.client.send(new GetCommand({
-			TableName: store.tableName,
-			Key: identityKey,
-			ConsistentRead: true
-		}));
-		if (accepted !== void 0) return;
-		const current = await loadInsightsInstallationItem(store, row.install_id);
-		const actions = [
-			{ Put: {
-				TableName: store.tableName,
-				Item: identityKey,
-				ConditionExpression: "attribute_not_exists(#pk)",
-				ExpressionAttributeNames: { "#pk": "pk" }
-			} },
-			{ Put: {
-				TableName: store.tableName,
-				Item: eventItem
-			} },
-			...bundleItem === null ? [] : [{ Put: {
-				TableName: store.tableName,
-				Item: bundleItem
-			} }]
-		];
-		if (current === null || advancesInsightsInstallation(next, current.row)) {
-			actions.push({ Put: {
-				TableName: store.tableName,
-				Item: toInsightsInstallationItem(next),
-				ConditionExpression: current === null ? "attribute_not_exists(#pk)" : "#orderKey = :currentOrderKey",
-				ExpressionAttributeNames: current === null ? { "#pk": "pk" } : { "#orderKey": "order_key" },
-				...current === null ? {} : { ExpressionAttributeValues: { ":currentOrderKey": current.order_key } }
-			} });
-			if (current !== null && current.row.user_id !== null && current.row.user_id !== next.user_id) actions.push({ Delete: {
-				TableName: store.tableName,
-				Key: {
-					pk: insightsUserPartition(current.row.user_id),
-					sk: current.row.install_id
+		/** Plain BatchWriteItem deletes: 1 write unit per KB each, not a transaction's 2. */
+		async deleteConsumed(keys) {
+			for (let at = 0; at < keys.length; at += WRITE_BATCH) {
+				let pending = keys.slice(at, at + WRITE_BATCH).map(({ pk, sk }) => ({ DeleteRequest: { Key: {
+					pk,
+					sk
+				} } }));
+				for (let round = 0; pending.length > 0; round += 1) {
+					if (round > 0) await sleep(2 ** round * 10);
+					const RequestItems = { [tableName]: pending };
+					const { UnprocessedItems } = await documents.send(new BatchWriteCommand({ RequestItems })).catch(missingTable);
+					pending = UnprocessedItems?.[tableName] ?? [];
 				}
-			} });
-			if (next.user_id !== null) actions.push({ Put: {
-				TableName: store.tableName,
-				Item: toInsightsUserItem({
-					...next,
-					user_id: next.user_id
-				})
-			} });
-		}
-		try {
-			await commitDynamoDBTransaction(store, actions);
-			return;
-		} catch (error) {
-			if (!isDynamoDBTransactionConflict(error)) throw error;
-			const { Item } = await store.client.send(new GetCommand({
-				TableName: store.tableName,
-				Key: identityKey,
-				ConsistentRead: true
-			}));
-			if (Item !== void 0) return;
-			if (attempt === 2) throw error;
-		}
-	}
-};
-const insightsEventRange = (input) => {
-	const upperExclusive = input.after ? `${timestampSortKey(input.after.receivedAtMs)}#${input.after.id}` : `${timestampSortKey(input.beforeReceivedAtMs)}#`;
-	const upper = `${upperExclusive.slice(0, -1)}${String.fromCharCode(upperExclusive.charCodeAt(upperExclusive.length - 1) - 1)}~`;
-	const movement = input.filter.kind === "installationMovement";
-	const partition = movement ? insightsMovementPartition(input.filter.installId) : input.filter.kind === "bundle" ? insightsBundlePartition(input.filter) : DYNAMODB_INSIGHTS_PARTITION;
-	return {
-		partition,
-		query: {
-			...movement ? { IndexName: DYNAMODB_UPDATE_INDEX_NAME } : { ConsistentRead: true },
-			KeyConditionExpression: "#partition = :partition AND #order BETWEEN :since AND :upper",
-			ExpressionAttributeNames: {
-				"#partition": movement ? "gsi1pk" : "pk",
-				"#order": movement ? "gsi1sk" : "sk"
-			},
-			ExpressionAttributeValues: {
-				":partition": partition,
-				":since": `${timestampSortKey(input.sinceMs ?? 0)}#`,
-				":upper": upper
 			}
-		}
-	};
-};
-const createDynamoDBInsightsTable = (store) => ({
-	record: (input) => recordDynamoDBInsightsEvent(store, input),
-	async listEvents(input) {
-		if ((input.sinceMs ?? 0) === input.beforeReceivedAtMs) return [];
-		const range = insightsEventRange(input);
-		const rows = [];
-		let exclusiveStartKey;
-		do {
-			const page = await store.client.send(new QueryCommand({
-				TableName: store.tableName,
-				...range.query,
-				ExclusiveStartKey: exclusiveStartKey,
-				Limit: input.limit - rows.length,
-				ScanIndexForward: false
-			}));
-			rows.push(...(page.Items ?? []).slice(0, input.limit - rows.length).map((item) => parseOfficialRowItem(item, input.filter.kind === "bundle" ? range.partition : DYNAMODB_INSIGHTS_PARTITION, isBundleEventRow).row));
-			exclusiveStartKey = page.LastEvaluatedKey;
-		} while (rows.length < input.limit && exclusiveStartKey !== void 0);
-		return rows;
-	},
-	async findInstallations(input) {
-		if ("installId" in input) {
-			const stored = await loadInsightsInstallationItem(store, input.installId);
-			return stored === null ? [] : [stored.row];
-		}
-		const partition = insightsUserPartition(input.userId);
-		const rows = [];
-		let exclusiveStartKey;
-		do {
-			const page = await store.client.send(new QueryCommand({
-				TableName: store.tableName,
-				ConsistentRead: true,
-				ExclusiveStartKey: exclusiveStartKey,
-				KeyConditionExpression: input.afterInstallId === void 0 ? "#pk = :pk" : "#pk = :pk AND #sk > :after",
-				ExpressionAttributeNames: {
-					"#pk": "pk",
-					...input.afterInstallId === void 0 ? {} : { "#sk": "sk" }
-				},
+		},
+		async query({ pk, gte, lt, lte, order, limit, after }) {
+			let condition = "pk = :pk";
+			const between = gte !== void 0 && lt !== void 0;
+			if (between) condition += " AND sk BETWEEN :gte AND :lte";
+			else if (gte !== void 0) condition += " AND sk >= :gte";
+			else if (lt !== void 0) condition += " AND sk < :lt";
+			const result = await documents.send(new QueryCommand({
+				TableName: tableName,
+				KeyConditionExpression: condition,
 				ExpressionAttributeValues: {
-					":pk": partition,
-					...input.afterInstallId === void 0 ? {} : { ":after": input.afterInstallId }
+					":pk": pk,
+					":gte": gte,
+					...between ? { ":lte": lte ?? lt } : { ":lt": lt }
 				},
-				Limit: input.limit - rows.length,
-				ScanIndexForward: true
-			}));
-			for (const item of (page.Items ?? []).slice(0, input.limit - rows.length)) {
-				const stored = parseInsightsInstallationItem(item, partition);
-				const current = await loadInsightsInstallationItem(store, stored.row.install_id);
-				if (current?.row.user_id === input.userId) rows.push(current.row);
-			}
-			exclusiveStartKey = page.LastEvaluatedKey;
-		} while (rows.length < input.limit && exclusiveStartKey !== void 0);
-		return rows;
-	},
-	async countInstallations(input) {
-		let count = 0;
-		let exclusiveStartKey;
-		do {
-			const page = await store.client.send(new QueryCommand({
-				TableName: store.tableName,
+				ScanIndexForward: order === "asc",
 				ConsistentRead: true,
-				ExclusiveStartKey: exclusiveStartKey,
-				KeyConditionExpression: "#pk = :pk",
-				FilterExpression: "#row.#platform = :platform AND #row.#channel = :channel AND #row.#received >= :since" + (input.bundleId === void 0 ? "" : " AND #row.#bundle = :bundle"),
-				ExpressionAttributeNames: {
-					"#pk": "pk",
-					"#row": "row",
-					"#platform": "platform",
-					"#channel": "channel",
-					"#received": "received_at_ms",
-					...input.bundleId === void 0 ? {} : { "#bundle": "to_bundle_id" }
-				},
-				ExpressionAttributeValues: {
-					":pk": DYNAMODB_INSIGHTS_INSTALLATIONS_PARTITION,
-					":platform": input.platform,
-					":channel": input.channel,
-					":since": input.sinceMs,
-					...input.bundleId === void 0 ? {} : { ":bundle": input.bundleId }
-				},
-				Select: "COUNT",
-				ScanIndexForward: true
-			}));
-			count += page.Count ?? 0;
-			exclusiveStartKey = page.LastEvaluatedKey;
-		} while (exclusiveStartKey !== void 0);
-		return count;
-	},
-	async countEvents(input) {
-		if (input.sinceMs === input.beforeReceivedAtMs) return 0;
-		const { query } = insightsEventRange({
-			...input,
-			filter: {
-				kind: "bundle",
-				...input.filter
-			},
-			limit: 1
-		});
-		let count = 0;
-		let exclusiveStartKey;
-		do {
-			const page = await store.client.send(new QueryCommand({
-				TableName: store.tableName,
-				...query,
-				ExclusiveStartKey: exclusiveStartKey,
-				Select: "COUNT"
-			}));
-			count += page.Count ?? 0;
-			exclusiveStartKey = page.LastEvaluatedKey;
-		} while (exclusiveStartKey !== void 0);
-		return count;
-	}
-});
-const apiKeyItem = (row, version) => ({
-	pk: DYNAMODB_API_KEY_PARTITION,
-	sk: row.id,
-	version,
-	row
-});
-const loadApiKey = async (store, id) => {
-	const result = await store.client.send(new GetCommand({
-		TableName: store.tableName,
-		Key: {
-			pk: DYNAMODB_API_KEY_PARTITION,
-			sk: id
+				Limit: Math.min(limit, nativePageSize ?? limit),
+				ExclusiveStartKey: after === void 0 ? void 0 : {
+					pk,
+					sk: after
+				}
+			})).catch(missingTable);
+			return {
+				items: (result.Items ?? []).map((item) => ({
+					sk: item.sk,
+					value: toRow(item)
+				})),
+				more: result.LastEvaluatedKey !== void 0
+			};
 		},
-		ConsistentRead: true
-	}));
-	return result.Item === void 0 ? null : parseOfficialRowItem(result.Item, DYNAMODB_API_KEY_PARTITION, isApiKeyRow);
-};
-const createDynamoDBApiKeyTable = (store) => {
-	const findByHash = async (hash) => {
-		const lookup = await store.client.send(new GetCommand({
-			TableName: store.tableName,
-			Key: {
-				pk: DYNAMODB_API_KEY_HASH_PARTITION,
-				sk: hash
-			},
-			ConsistentRead: true
-		}));
-		const id = lookup.Item?.api_key_id;
-		if (lookup.Item === void 0) return null;
-		if (typeof id !== "string") throw new DynamoDBStoredItemError();
-		return (await loadApiKey(store, id))?.row ?? null;
-	};
-	return {
-		async create(row) {
-			if (await findByHash(row.hash) !== null) return "existing";
+		async write(ops) {
 			try {
-				await commitDynamoDBTransaction(store, [{ Put: {
-					TableName: store.tableName,
-					Item: boundedDynamoDBMetadataItem(apiKeyItem(row, 1)),
-					ConditionExpression: "attribute_not_exists(#pk)",
-					ExpressionAttributeNames: { "#pk": "pk" }
-				} }, { Put: {
-					TableName: store.tableName,
-					Item: {
-						pk: DYNAMODB_API_KEY_HASH_PARTITION,
-						sk: row.hash,
-						api_key_id: row.id
-					},
-					ConditionExpression: "attribute_not_exists(#pk)",
-					ExpressionAttributeNames: { "#pk": "pk" }
-				} }]);
-				return "created";
+				await documents.send(new TransactWriteCommand({
+					TransactItems: ops.map((op) => toTransactItem(tableName, op)),
+					ClientRequestToken: crypto.randomUUID()
+				}));
+				return { ok: true };
 			} catch (error) {
-				if (await findByHash(row.hash) !== null) return "existing";
-				throw error;
+				const { CancellationReasons = [] } = error;
+				const codes = CancellationReasons.map(({ Code }) => Code);
+				const failed = codes.indexOf("ConditionalCheckFailed");
+				if (failed !== -1) return {
+					ok: false,
+					failedOp: failed
+				};
+				return [nameOf(error), ...codes].some((code) => TRANSIENT.has(code)) ? {
+					ok: false,
+					retry: true
+				} : missingTable(error);
 			}
 		},
-		findByHash,
-		async list() {
-			const rows = [];
-			let exclusiveStartKey;
-			do {
-				const page = await store.client.send(new QueryCommand({
-					TableName: store.tableName,
-					ExclusiveStartKey: exclusiveStartKey,
-					KeyConditionExpression: "#pk = :pk",
-					ExpressionAttributeNames: { "#pk": "pk" },
-					ExpressionAttributeValues: { ":pk": DYNAMODB_API_KEY_PARTITION },
-					ConsistentRead: true
+		migrations: { 
+		/**
+		* Creates the table for local and test runs, and turns on its TTL,
+		* which every table the store runs on needs; `hot-updater init`
+		* creates it in AWS.
+		*/
+async apply() {
+			try {
+				await client.send(new DescribeTableCommand({ TableName: tableName }));
+			} catch (error) {
+				if (nameOf(error) !== "ResourceNotFoundException") throw error;
+				await client.send(new CreateTableCommand({
+					TableName: tableName,
+					AttributeDefinitions: [{
+						AttributeName: "pk",
+						AttributeType: "S"
+					}, {
+						AttributeName: "sk",
+						AttributeType: "S"
+					}],
+					KeySchema: [{
+						AttributeName: "pk",
+						KeyType: "HASH"
+					}, {
+						AttributeName: "sk",
+						KeyType: "RANGE"
+					}],
+					BillingMode: "PAY_PER_REQUEST"
 				}));
-				rows.push(...(page.Items ?? []).map((item) => parseOfficialRowItem(item, DYNAMODB_API_KEY_PARTITION, isApiKeyRow).row));
-				exclusiveStartKey = page.LastEvaluatedKey;
-			} while (exclusiveStartKey !== void 0);
-			return rows.sort((left, right) => right.created_at_ms - left.created_at_ms || left.id.localeCompare(right.id));
-		},
-		async revoke({ id, revokedAtMs }) {
-			const current = await loadApiKey(store, id);
-			if (current === null) return null;
-			const row = {
-				...current.row,
-				revoked_at_ms: revokedAtMs
+				await waitUntilTableExists({
+					client,
+					maxWaitTime: 120,
+					minDelay: 1,
+					maxDelay: 1
+				}, { TableName: tableName });
+			}
+			const { TimeToLiveDescription: ttl } = await client.send(new DescribeTimeToLiveCommand({ TableName: tableName }));
+			if (ttl?.TimeToLiveStatus?.startsWith("ENABL")) return;
+			const input = {
+				TableName: tableName,
+				TimeToLiveSpecification: {
+					AttributeName: DYNAMODB_TTL_ATTRIBUTE,
+					Enabled: true
+				}
 			};
-			await store.client.send(new PutCommand({
-				TableName: store.tableName,
-				Item: boundedDynamoDBMetadataItem(apiKeyItem(row, current.version + 1)),
-				ConditionExpression: "#version = :currentVersion",
-				ExpressionAttributeNames: { "#version": "version" },
-				ExpressionAttributeValues: { ":currentVersion": current.version }
-			}));
-			return row;
-		}
+			await client.send(new UpdateTimeToLiveCommand(input));
+		} }
 	};
 };
-const DYNAMODB_UPDATE_INDEX_NAME = "hot-updater-update-index";
-const dynamoDB = (config) => {
-	const { apiBasePath = "/release-catalogs", cloudfrontDistributionId, shouldWaitForInvalidation = false, tableName, ...clientConfig } = config;
-	const client = DynamoDBDocumentClient.from(new DynamoDBClient(clientConfig), { marshallOptions: { removeUndefinedValues: true } });
-	const cloudFront = cloudfrontDistributionId ? new CloudFrontClient({
-		credentials: clientConfig.credentials,
-		region: clientConfig.region
-	}) : null;
-	const store = {
+//#endregion
+//#region src/dynamoDB.ts
+/** The DynamoDB client ignores the CloudFront and batching settings. */
+const adapterOf = ({ tableName, ...clientConfig }) => {
+	const client = new DynamoDBClient(clientConfig);
+	const store = createDynamoDBStore({
 		client,
 		tableName
+	});
+	return {
+		client,
+		adapter: createKvAdapter({ store })
 	};
-	const crud = createDynamoDBCrud(store, DYNAMODB_UPDATE_INDEX_NAME);
-	const invalidateUpdateRoutes = async () => {
-		if (!cloudFront || !cloudfrontDistributionId) return;
-		try {
-			await invalidateCloudFront(cloudFront, cloudfrontDistributionId, [`${apiBasePath.replace(/\/+$/, "")}/*`], { shouldWait: shouldWaitForInvalidation });
-		} catch (error) {
-			console.warn("[hot-updater/aws] CloudFront invalidation failed; continuing without cache invalidation.", {
-				distributionId: cloudfrontDistributionId,
-				error: error instanceof Error ? error.message : "Unknown error"
-			});
-		}
-	};
-	const adapter = createDatabasePluginAdapter("dynamoDB", {
-		...crud,
-		commit: createDynamoDBCommit(store),
-		dispose: async () => {
+};
+/**
+* Creates the table when it is missing and writes the schema settings of
+* core and `plugins`, the plugins the server runs, which the database checks
+* before its first read. `hot-updater init` runs it in AWS with the managed
+* server's plugins.
+*/
+const migrateDynamoDB = (config, plugins = []) => {
+	const { client, adapter } = adapterOf(config);
+	return migrateCoreSchema(adapter, "dynamoDB", plugins).finally(() => client.destroy());
+};
+/**
+* Hot Updater's database on one DynamoDB table, through the storage engine.
+* With a distribution, it gives core the CloudFront invalidation core runs
+* after a write that changes what the update-check routes answer.
+*/
+const dynamoDB = (config) => {
+	const { client, adapter } = adapterOf(config);
+	const cloudFront = createUpdateRouteInvalidation(config);
+	return {
+		...createEngineDatabase({
+			name: "dynamoDB",
+			adapter,
+			onCachedRoutesChange: cloudFront?.invalidate,
+			aggregateBatching: config.aggregateBatching ?? {}
+		}),
+		async dispose() {
+			await adapter.dispose?.();
 			client.destroy();
 			cloudFront?.destroy();
 		}
-	});
-	return createDatabasePlugin({
-		name: "dynamoDB",
-		models: {
-			...adapter.models,
-			bundlePatches: createDynamoDBBundlePatchTable(store, DYNAMODB_UPDATE_INDEX_NAME),
-			insights: createDynamoDBInsightsTable(store),
-			apiKeys: createDynamoDBApiKeyTable(store)
-		},
-		async commit(input) {
-			const result = await adapter.commit(input);
-			if (result.committed && input.changes.some(({ model }) => model === "bundles" || model === "bundlePatches")) await invalidateUpdateRoutes();
-			return result;
-		},
-		dispose: adapter.dispose
-	});
+	};
 };
 //#endregion
 //#region src/runtimeAwsConfig.ts
@@ -2091,6 +448,21 @@ function s3Storage(config) {
 		const value = [normalizedBasePath, normalizedPrefix].filter(Boolean).join("/");
 		return value ? `${value}/` : "";
 	};
+	/**
+	* The URI `put` returns for the key, or null for a key no `put` writes,
+	* such as a folder marker that ends in "/".
+	*/
+	const getListedStorageUri = (key) => {
+		try {
+			return createStorageUri({
+				bucket: bucketName,
+				key,
+				protocol: "s3"
+			});
+		} catch {
+			return null;
+		}
+	};
 	const getRelativeKey = (key) => {
 		if (!normalizedBasePath) return key;
 		const basePrefix = `${normalizedBasePath}/`;
@@ -2101,7 +473,7 @@ function s3Storage(config) {
 		if (parsed.bucket !== bucketName) throw new Error(`Bucket name mismatch: expected "${bucketName}", but found "${parsed.bucket}".`);
 		return parsed;
 	};
-	return createStoragePlugin({
+	return createStorageAdapter({
 		name: "s3Storage",
 		protocol: "s3",
 		async listObjects(prefix) {
@@ -2115,11 +487,13 @@ function s3Storage(config) {
 				}));
 				for (const object of response.Contents ?? []) {
 					if (!object.Key) continue;
+					const storageUri = getListedStorageUri(object.Key);
+					if (storageUri === null) continue;
 					objects.push({
 						key: getRelativeKey(object.Key),
 						lastModifiedAt: object.LastModified,
 						size: object.Size ?? 0,
-						storageUri: `s3://${bucketName}/${object.Key}`
+						storageUri
 					});
 				}
 				continuationToken = response.NextContinuationToken;
@@ -2206,4 +580,11 @@ function s3Storage(config) {
 	});
 }
 //#endregion
-export { DYNAMODB_UPDATE_INDEX_NAME, cloudFrontDownloadUrl, dynamoDB, s3Storage };
+//#region src/plugins.ts
+/**
+* The plugins the managed AWS server runs: Insights, and API keys on every
+* client route. Its Lambda@Edge function imports this list.
+*/
+const plugins = [insights(), apiKeys()];
+//#endregion
+export { cloudFrontDownloadUrl, dynamoDB, migrateDynamoDB, plugins, s3Storage };