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

package/dist/core/operations.mjs

@@ -0,0 +1,350 @@
+import { DatabaseConstraintError } from "../database/errors.mjs";
+import { toBundleRow, toReleaseRow } from "./reads.mjs";
+import { deleteBundle, deleteChannel, insertChannel, replaceBundlePatches, updateBundle } from "./writes.mjs";
+import { changeRelease, changeReleases, readCatalog, rebuildScope } from "./releases.mjs";
+import { DatabaseBundleNotFoundError, ReleaseCatalogMutationError, ReleaseManagementError, bundleToPatchRows, bundleToRow, createUUIDv7After, isUUIDv7, rowToBundle } from "@hot-updater/plugin-core";
+import { DatabaseRowReferencedError } from "@hot-updater/plugin-core/internal";
+import { createReleaseCatalogScopeKey, decodeChannelKey, encodeChannelKey } from "@hot-updater/core";
+//#region src/core/operations.ts
+/** Carries a preflight's result out of the transaction it stops, so nothing is written. */
+var Preflight = class extends Error {
+	result;
+	constructor(result) {
+		super("preflight");
+		this.result = result;
+	}
+};
+const dryRun = async (db, read) => {
+	try {
+		await db.transaction(async (tx) => {
+			throw new Preflight(await read(tx));
+		});
+	} catch (error) {
+		if (error instanceof Preflight) return error.result;
+		throw error;
+	}
+	throw new Error("A preflight transaction returned without its result.");
+};
+/** A channel's catalog scope for a platform, and a fingerprint when it has one. */
+const scopeOf = (channel, platform, fingerprintHash) => {
+	const channelKey = encodeChannelKey(channel.name);
+	return fingerprintHash === null ? {
+		channelId: channel.id,
+		channelName: channel.name,
+		fingerprintHash,
+		platform,
+		scopeKey: createReleaseCatalogScopeKey({
+			channelKey,
+			platform,
+			strategy: "APP_VERSION"
+		}),
+		strategy: "APP_VERSION"
+	} : {
+		channelId: channel.id,
+		channelName: channel.name,
+		fingerprintHash,
+		platform,
+		scopeKey: createReleaseCatalogScopeKey({
+			channelKey,
+			fingerprintHash,
+			platform,
+			strategy: "FINGERPRINT"
+		}),
+		strategy: "FINGERPRINT"
+	};
+};
+/** A release and its scope, checked against the revision the caller saw. */
+const loadTarget = async (tx, { releaseId, expectedRevision }) => {
+	const row = await tx.findOne("releases", { id: releaseId });
+	if (row === null) throw new ReleaseManagementError("RELEASE_NOT_FOUND", `Release "${releaseId}" was not found.`);
+	const release = toReleaseRow(row);
+	if (expectedRevision !== void 0 && expectedRevision !== release.revision) throw new ReleaseManagementError("VERSION_CONFLICT", `Release "${release.id}" is revision ${release.revision}; expected ${expectedRevision}.`);
+	const catalog = await tx.findOne("release_catalogs", { scope_key: release.scope_key });
+	if (catalog === null) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release "${release.id}" has no catalog projection.`);
+	return {
+		release,
+		scope: {
+			channelId: release.channel_id,
+			channelName: decodeChannelKey(catalog.channel_key),
+			fingerprintHash: release.fingerprint_hash,
+			platform: release.platform,
+			scopeKey: release.scope_key,
+			strategy: release.strategy
+		}
+	};
+};
+const policyUpdate = (release, patch, updatedAtMs) => {
+	if (patch.fingerprintHash !== void 0 && patch.fingerprintHash !== release.fingerprint_hash) throw new ReleaseManagementError("SCOPE_MOVE_UNSUPPORTED", "Changing a fingerprint target requires an atomic Release scope move.");
+	return {
+		...patch.enabled === void 0 ? {} : { enabled: patch.enabled },
+		...patch.message === void 0 ? {} : { message: patch.message },
+		...patch.rolloutCohortCount === void 0 ? {} : { rollout_cohort_count: patch.rolloutCohortCount },
+		...patch.shouldForceUpdate === void 0 ? {} : { should_force_update: patch.shouldForceUpdate },
+		...patch.targetAppVersion === void 0 ? {} : { target_app_version: patch.targetAppVersion },
+		...patch.targetCohorts === void 0 ? {} : { target_cohorts: [...patch.targetCohorts] },
+		updated_at_ms: updatedAtMs
+	};
+};
+const mutationResult = ({ catalog, release }) => ({
+	attempts: 1,
+	catalog,
+	release
+});
+/** The scope a catalog row names, for a rebuild. */
+const catalogScope = async (tx, scopeKey) => {
+	const row = await tx.findOne("release_catalogs", { scope_key: scopeKey });
+	if (row === null) throw new Error(`Release catalog "${scopeKey}" was not found.`);
+	return {
+		channelId: row.channel_id,
+		channelName: decodeChannelKey(row.channel_key),
+		fingerprintHash: row.fingerprint_hash,
+		platform: row.platform,
+		scopeKey: row.scope_key,
+		strategy: row.strategy
+	};
+};
+/**
+* Core's typed writes: each runs in one engine transaction rooted at the
+* catalogs it changes, so a concurrent change reruns it instead of
+* publishing a stale catalog.
+*/
+const createCoreOperations = (db, { now = Date.now } = {}) => {
+	const ensureChannel = async (name) => (await insertChannel(db, {
+		id: `channel:${encodeChannelKey(name)}`,
+		name
+	})).row;
+	/**
+	* Runs a write that ensured its channels first. A channel deleted between
+	* that and the write refuses the write, so it runs again and ensures it anew.
+	*/
+	const withChannels = async (write) => {
+		for (let attempt = 1;; attempt += 1) try {
+			return await write();
+		} catch (error) {
+			if (attempt < 3 && error instanceof DatabaseConstraintError && error.reason === "not_found" && error.model === "channels") continue;
+			throw error;
+		}
+	};
+	const deployOnce = async (deployments) => {
+		const channels = /* @__PURE__ */ new Map();
+		for (const { release } of deployments) if (!channels.has(release.channel)) channels.set(release.channel, await ensureChannel(release.channel));
+		const platforms = /* @__PURE__ */ new Map();
+		for (const deployment of deployments) {
+			if (!("bundleId" in deployment) || platforms.has(deployment.bundleId)) continue;
+			const row = await db.findOne("bundles", { id: deployment.bundleId });
+			if (row === null) throw new DatabaseBundleNotFoundError(deployment.bundleId);
+			platforms.set(deployment.bundleId, toBundleRow(row).platform);
+		}
+		const updatedAtMs = now();
+		return (await changeReleases(db, deployments.map((deployment) => {
+			const { release: policy } = deployment;
+			const stored = "bundleId" in deployment;
+			const bundleId = stored ? deployment.bundleId : deployment.bundle.id;
+			const platform = stored ? platforms.get(deployment.bundleId) : deployment.bundle.platform;
+			const scope = scopeOf(channels.get(policy.channel), platform, policy.fingerprintHash);
+			return {
+				scope,
+				...stored ? {} : { bundle: {
+					row: bundleToRow(deployment.bundle),
+					patches: bundleToPatchRows(deployment.bundle)
+				} },
+				change: {
+					operation: "insert",
+					row: {
+						bundle_id: bundleId,
+						channel_id: scope.channelId,
+						created_at_ms: updatedAtMs,
+						enabled: policy.enabled,
+						fingerprint_hash: policy.fingerprintHash,
+						kind: "BUNDLE",
+						message: policy.message,
+						operation: "DEPLOY",
+						platform,
+						revision: 1,
+						rollout_cohort_count: policy.rolloutCohortCount ?? 1e3,
+						scope_key: scope.scopeKey,
+						should_force_update: policy.shouldForceUpdate,
+						source_release_id: null,
+						strategy: scope.strategy,
+						target_app_version: policy.targetAppVersion,
+						target_cohorts: policy.targetCohorts ?? [],
+						updated_at_ms: updatedAtMs
+					}
+				},
+				updatedAtMs
+			};
+		}))).map(mutationResult);
+	};
+	return {
+		deploy: (deployments) => withChannels(() => deployOnce(deployments)),
+		updateReleasePolicy: (input) => {
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { release, scope } = await loadTarget(tx, input);
+				return mutationResult(await changeRelease(tx, {
+					scope,
+					change: {
+						operation: "update",
+						id: release.id,
+						update: policyUpdate(release, input.patch, updatedAtMs)
+					},
+					updatedAtMs
+				}));
+			});
+		},
+		preflightReleasePolicy: (input) => {
+			const updatedAtMs = now();
+			return dryRun(db, async (tx) => {
+				const { release, scope } = await loadTarget(tx, input);
+				const stored = await readCatalog(tx, scope.scopeKey);
+				const changed = await changeRelease(tx, {
+					scope,
+					change: {
+						operation: "update",
+						id: release.id,
+						update: policyUpdate(release, input.patch, updatedAtMs)
+					},
+					updatedAtMs
+				});
+				return {
+					catalog: changed.catalog,
+					currentCatalog: stored.catalog,
+					diagnostics: changed.diagnostics,
+					expectedReleaseRevision: release.revision,
+					release: changed.release
+				};
+			});
+		},
+		deleteRelease: (input) => db.transaction(async (tx) => {
+			const { release, scope } = await loadTarget(tx, input);
+			if (release.enabled) throw new ReleaseManagementError("ENABLED_RELEASE", `Disable Release "${release.id}" before hard deletion.`);
+			return mutationResult(await changeRelease(tx, {
+				scope,
+				change: {
+					operation: "delete",
+					id: release.id
+				},
+				updatedAtMs: now()
+			}));
+		}),
+		promoteRelease: (input) => withChannels(async () => {
+			const checkSource = (source) => {
+				if (source.kind !== "BUNDLE" || source.bundle_id === null) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Only a Bundle Release can be promoted.");
+			};
+			checkSource((await db.transaction((tx) => loadTarget(tx, input))).release);
+			const targetChannel = input.targetChannel.trim();
+			if (targetChannel.length === 0) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Promotion requires a target channel.");
+			const channel = await ensureChannel(targetChannel);
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { release: source, scope: sourceScope } = await loadTarget(tx, input);
+				checkSource(source);
+				const targetScope = scopeOf(channel, source.platform, source.fingerprint_hash);
+				if (targetScope.scopeKey === sourceScope.scopeKey) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Source and target Release scopes are the same.");
+				const { rows } = await tx.findMany("releases", {
+					index: "byScope",
+					where: { scope_key: targetScope.scopeKey },
+					order: "desc",
+					limit: 1
+				});
+				const floor = [
+					rows[0]?.id ?? null,
+					source.id,
+					source.bundle_id
+				].filter((id) => id !== null && isUUIDv7(id)).sort().at(-1);
+				const moved = input.action === "move" ? await changeRelease(tx, {
+					scope: sourceScope,
+					change: {
+						operation: "update",
+						id: source.id,
+						update: {
+							enabled: false,
+							updated_at_ms: updatedAtMs
+						}
+					},
+					updatedAtMs
+				}) : null;
+				const target = await changeRelease(tx, {
+					scope: targetScope,
+					change: {
+						operation: "insert",
+						row: {
+							...source,
+							id: createUUIDv7After(floor ?? null, updatedAtMs),
+							revision: 1,
+							scope_key: targetScope.scopeKey,
+							channel_id: targetScope.channelId,
+							enabled: true,
+							rollout_cohort_count: 1e3,
+							target_cohorts: [],
+							operation: "PROMOTE",
+							source_release_id: source.id,
+							created_at_ms: updatedAtMs,
+							updated_at_ms: updatedAtMs
+						}
+					},
+					updatedAtMs
+				});
+				return {
+					source: moved === null ? null : mutationResult(moved),
+					target: mutationResult(target)
+				};
+			});
+		}),
+		rebuildReleaseCatalog: (scopeKey) => {
+			const updatedAtMs = now();
+			return db.transaction(async (tx) => {
+				const { current: _current, ...rebuilt } = await rebuildScope(tx, await catalogScope(tx, scopeKey), updatedAtMs);
+				return {
+					attempts: 1,
+					...rebuilt
+				};
+			});
+		},
+		preflightReleaseCatalogRebuild: (scopeKey) => {
+			const updatedAtMs = now();
+			return dryRun(db, async (tx) => {
+				const rebuilt = await rebuildScope(tx, await catalogScope(tx, scopeKey), updatedAtMs);
+				return {
+					changed: rebuilt.changed,
+					currentCatalog: rebuilt.current,
+					diagnostics: rebuilt.diagnostics,
+					projectedCatalog: rebuilt.catalog
+				};
+			});
+		},
+		ensureChannel,
+		deleteChannel: (id) => deleteChannel(db, id),
+		updateBundle: (id, update) => db.transaction(async (tx) => {
+			const current = await tx.findOne("bundles", { id });
+			if (current === null) throw new DatabaseBundleNotFoundError(id);
+			const { patches, ...fields } = update;
+			const next = {
+				...rowToBundle(toBundleRow(current)),
+				...fields,
+				id
+			};
+			const { id: _id, ...set } = bundleToRow(next);
+			updateBundle(tx, current, set);
+			if (patches !== void 0) await replaceBundlePatches(tx, current, bundleToPatchRows({
+				...next,
+				patches
+			}));
+		}),
+		deleteBundles: async (ids) => {
+			try {
+				await db.transaction(async (tx) => {
+					for (const id of new Set(ids)) {
+						const current = await tx.findOne("bundles", { id });
+						if (current !== null) await deleteBundle(tx, current);
+					}
+				});
+			} catch (error) {
+				if (error instanceof DatabaseConstraintError && error.reason === "referenced") throw new DatabaseRowReferencedError();
+				throw error;
+			}
+		}
+	};
+};
+//#endregion
+export { createCoreOperations };

package/dist/core/reads.cjs

@@ -0,0 +1,273 @@
+const require_releaseCatalog = require("../db/releaseCatalog.cjs");
+const require_updateArtifacts = require("../db/updateArtifacts.cjs");
+const require_baseCandidates = require("./baseCandidates.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/core/reads.ts
+const PAGE = 500;
+const pick = (fields) => (row) => Object.fromEntries(fields.map((field) => [field, row[field]]));
+const toBundleRow = pick([
+	"id",
+	"platform",
+	"git_commit_hash",
+	"metadata",
+	"manifest_storage_uri",
+	"manifest_file_hash",
+	"asset_base_storage_uri"
+]);
+const toPatchRow = pick([
+	"id",
+	"bundle_id",
+	"base_bundle_id",
+	"base_file_hash",
+	"patch_file_hash",
+	"patch_storage_uri",
+	"byte_size",
+	"order_index"
+]);
+const toReleaseRow = pick([
+	"id",
+	"revision",
+	"scope_key",
+	"channel_id",
+	"platform",
+	"kind",
+	"bundle_id",
+	"strategy",
+	"target_app_version",
+	"fingerprint_hash",
+	"enabled",
+	"should_force_update",
+	"message",
+	"rollout_cohort_count",
+	"target_cohorts",
+	"operation",
+	"source_release_id",
+	"created_at_ms",
+	"updated_at_ms"
+]);
+const toCatalogRow = pick([
+	"scope_key",
+	"catalog_id",
+	"strategy",
+	"channel_id",
+	"channel_key",
+	"platform",
+	"fingerprint_hash",
+	"generation",
+	"payload",
+	"catalog_hash",
+	"byte_size",
+	"is_tombstone",
+	"updated_at_ms"
+]);
+const toChannelRow = pick(["id", "name"]);
+/** Every page of one read, in order. */
+const drain = async (read) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await read(cursor === void 0 ? {} : { cursor });
+		rows.push(...page.rows);
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+/** Core's reads, each through one declared index or key. */
+const createCoreReads = (db, storage) => {
+	/** A bundle row's patches, exactly as many as its reference counter holds. */
+	const detail = async (row) => {
+		const count = row._refs_bundle_patches_bundle_id ?? 0;
+		const patches = [];
+		let cursor;
+		while (patches.length < count) {
+			const page = await db.findMany("bundle_patches", {
+				index: "byBundle",
+				where: { bundle_id: row.id },
+				limit: Math.min(count - patches.length, PAGE),
+				...cursor === void 0 ? {} : { cursor }
+			});
+			patches.push(...page.rows.map(toPatchRow));
+			if (page.next === void 0) break;
+			cursor = page.next;
+		}
+		return {
+			bundle: toBundleRow(row),
+			patches,
+			childCount: row._refs_bundle_patches_base_bundle_id ?? 0
+		};
+	};
+	const after = (input) => input.after === void 0 ? {} : { range: (input.order ?? "asc") === "asc" ? { gt: input.after } : { lt: input.after } };
+	return {
+		/** The update check: one point read of its scope's catalog. */
+		async getReleaseCatalog(input) {
+			const scopeKey = require_releaseCatalog.releaseCatalogScopeKeyOf(input);
+			const row = await db.findOne("release_catalogs", { scope_key: scopeKey });
+			return require_releaseCatalog.projectReleaseCatalogRow(row === null ? null : toCatalogRow(row), input, scopeKey);
+		},
+		/** Artifact resolution: one batch read of both bundles and one unique read of their patch. */
+		async getArtifactInfo(targetBundleId, currentBundleId, artifactProtocolVersion) {
+			const { readStorageText } = storage;
+			if (artifactProtocolVersion !== _hot_updater_core.ARTIFACT_PROTOCOL_VERSION || readStorageText === void 0) return null;
+			const withCurrent = currentBundleId !== _hot_updater_core.NIL_UUID;
+			const [[target, current], patch] = await Promise.all([db.findByKeys("bundles", withCurrent ? [{ id: targetBundleId }, { id: currentBundleId }] : [{ id: targetBundleId }]), withCurrent ? db.findOne("bundle_patches", {
+				bundle_id: targetBundleId,
+				base_bundle_id: currentBundleId
+			}) : null]);
+			if (target === null || target === void 0) return null;
+			return require_updateArtifacts.resolveManifestArtifacts({
+				currentBundle: current ? (0, _hot_updater_plugin_core.rowToBundle)(toBundleRow(current)) : null,
+				readStorageText,
+				resolveFileUrl: storage.resolveFileUrl,
+				targetBundle: (0, _hot_updater_plugin_core.rowToBundle)(toBundleRow(target), patch === null ? [] : [toPatchRow(patch)])
+			});
+		},
+		/** A bundle, its patches, and how many patches start from it. */
+		async getBundle(id) {
+			const row = await db.findOne("bundles", { id });
+			return row === null ? null : detail(row);
+		},
+		/** One page of the patches that start from a bundle, by target bundle id. */
+		/** Each base bundle's reference counter: one batch read of the bundle rows, and no patches. */
+		async countBundleChildren(baseBundleIds) {
+			const ids = [...new Set(baseBundleIds)];
+			if (ids.length === 0) return {};
+			const rows = await db.findByKeys("bundles", ids.map((id) => ({ id })));
+			return Object.fromEntries(ids.map((id, position) => [id, rows[position]?._refs_bundle_patches_base_bundle_id ?? 0]));
+		},
+		async listPatchesFromBase(baseBundleId, input) {
+			return (await db.findMany("bundle_patches", {
+				index: "byBase",
+				where: { base_bundle_id: baseBundleId },
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			})).rows.map(toPatchRow);
+		},
+		/** One page of bundles with their patches, oldest or newest first, optionally for one platform. */
+		async listBundles(input) {
+			const page = input.platform === void 0 ? await db.findMany("bundles", {
+				index: "all",
+				where: {},
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			}) : await db.findMany("bundles", {
+				index: "byPlatform",
+				where: { platform: input.platform },
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			});
+			return Promise.all(page.rows.map(detail));
+		},
+		/** Bundles in total or for one platform: one counter row. */
+		async countBundles(platform) {
+			const { rows } = await db.findAggregates("bundle_totals", {
+				index: "byPlatform",
+				where: { platform_key: platform ?? "*" },
+				limit: 1
+			});
+			return rows[0]?.bundles ?? 0;
+		},
+		/** Auto-patch bases for a new bundle: one point read of its scope's catalog. */
+		async findBaseBundleIds(candidateKey, bundleId, limit) {
+			const query = require_baseCandidates.parseBaseCandidateKey(candidateKey);
+			if (query === null) return [];
+			const row = await db.findOne("release_catalogs", { scope_key: query.scopeKey });
+			return row === null ? [] : require_baseCandidates.baseBundleIdsOf(toCatalogRow(row), query.range, bundleId, limit);
+		},
+		async getRelease(id) {
+			const row = await db.findOne("releases", { id });
+			return row === null ? null : toReleaseRow(row);
+		},
+		/** One page of releases through the index its filter names. */
+		async listReleases(input) {
+			const { filter } = input;
+			const options = {
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			};
+			return (filter.kind === "all" ? await db.findMany("releases", {
+				index: "all",
+				where: {},
+				...options
+			}) : filter.kind === "bundle" ? await db.findMany("releases", {
+				index: "byBundle",
+				where: { bundle_id: filter.bundleId },
+				...options
+			}) : filter.kind === "scope" ? filter.enabled === void 0 ? await db.findMany("releases", {
+				index: "byScope",
+				where: { scope_key: filter.scopeKey },
+				...options
+			}) : await db.findMany("releases", {
+				index: "byScopeEnabled",
+				where: {
+					scope_key: filter.scopeKey,
+					enabled: filter.enabled
+				},
+				...options
+			}) : filter.enabled === void 0 ? await db.findMany("releases", {
+				index: "byChannelPlatform",
+				where: {
+					channel_id: filter.channelId,
+					platform: filter.platform
+				},
+				...options
+			}) : await db.findMany("releases", {
+				index: "byChannelPlatformEnabled",
+				where: {
+					channel_id: filter.channelId,
+					platform: filter.platform,
+					enabled: filter.enabled
+				},
+				...options
+			})).rows.map(toReleaseRow);
+		},
+		/** A scope's newest release id: `byScope` descending, limit 1. */
+		async latestReleaseId(scopeKey) {
+			const { rows } = await db.findMany("releases", {
+				index: "byScope",
+				where: { scope_key: scopeKey },
+				order: "desc",
+				limit: 1
+			});
+			return rows[0]?.id ?? null;
+		},
+		async getReleaseCatalogRow(scopeKey) {
+			const row = await db.findOne("release_catalogs", { scope_key: scopeKey });
+			return row === null ? null : toCatalogRow(row);
+		},
+		async listReleaseCatalogs(input) {
+			return (await db.findMany("release_catalogs", {
+				index: "all",
+				where: {},
+				order: input.order ?? "asc",
+				limit: input.limit,
+				...after(input)
+			})).rows.map(toCatalogRow);
+		},
+		/** Every channel, by name. */
+		async listChannels() {
+			return (await drain((page) => db.findMany("channels", {
+				index: "all",
+				where: {},
+				limit: PAGE,
+				...page
+			}))).map(toChannelRow);
+		},
+		async findChannelByName(name) {
+			const row = await db.findOne("channels", { name });
+			return row === null ? null : toChannelRow(row);
+		}
+	};
+};
+//#endregion
+exports.createCoreReads = createCoreReads;
+exports.drain = drain;
+exports.toBundleRow = toBundleRow;
+exports.toCatalogRow = toCatalogRow;
+exports.toChannelRow = toChannelRow;
+exports.toPatchRow = toPatchRow;
+exports.toReleaseRow = toReleaseRow;

package/dist/core/reads.d.cts

@@ -0,0 +1,48 @@
+import "../database/engineReads.cjs";
+import { HotUpdaterDatabase } from "../database/database.cjs";
+import { ReleaseCatalogRequest } from "../db/releaseCatalog.cjs";
+import { CoreSchema } from "./schema.cjs";
+import { BundleDetail, BundlePatchRow, ChannelRow, KeysetInput, ReleaseCatalogRow, ReleaseFilter, ReleaseRow } from "@hot-updater/plugin-core";
+import { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
+//#region src/core/reads.d.ts
+type CoreDatabase = HotUpdaterDatabase<CoreSchema>;
+interface CoreStorage {
+  readonly readStorageText?: (storageUri: string) => Promise<string | null>;
+  readonly resolveFileUrl: (storageUri: string | null) => Promise<string | null>;
+}
+/** Core's reads, each through one declared index or key. */
+declare const createCoreReads: (db: CoreDatabase, storage: CoreStorage) => {
+  /** The update check: one point read of its scope's catalog. */
+  getReleaseCatalog(input: ReleaseCatalogRequest): Promise<ReleaseCatalog | null>;
+  /** Artifact resolution: one batch read of both bundles and one unique read of their patch. */
+  getArtifactInfo(targetBundleId: string, currentBundleId: string, artifactProtocolVersion: 1): Promise<ArtifactInfo | null>;
+  /** A bundle, its patches, and how many patches start from it. */
+  getBundle(id: string): Promise<BundleDetail | null>;
+  /** One page of the patches that start from a bundle, by target bundle id. */
+  /** Each base bundle's reference counter: one batch read of the bundle rows, and no patches. */
+  countBundleChildren(baseBundleIds: readonly string[]): Promise<Record<string, number>>;
+  listPatchesFromBase(baseBundleId: string, input: KeysetInput): Promise<BundlePatchRow[]>;
+  /** One page of bundles with their patches, oldest or newest first, optionally for one platform. */
+  listBundles(input: KeysetInput & {
+    readonly platform?: "ios" | "android";
+  }): Promise<BundleDetail[]>;
+  /** Bundles in total or for one platform: one counter row. */
+  countBundles(platform?: "ios" | "android"): Promise<number>;
+  /** Auto-patch bases for a new bundle: one point read of its scope's catalog. */
+  findBaseBundleIds(candidateKey: string, bundleId: string, limit: number): Promise<string[]>;
+  getRelease(id: string): Promise<ReleaseRow | null>;
+  /** One page of releases through the index its filter names. */
+  listReleases(input: KeysetInput & {
+    readonly filter: ReleaseFilter;
+  }): Promise<ReleaseRow[]>;
+  /** A scope's newest release id: `byScope` descending, limit 1. */
+  latestReleaseId(scopeKey: string): Promise<string | null>;
+  getReleaseCatalogRow(scopeKey: string): Promise<ReleaseCatalogRow | null>;
+  listReleaseCatalogs(input: KeysetInput): Promise<ReleaseCatalogRow[]>;
+  /** Every channel, by name. */
+  listChannels(): Promise<ChannelRow[]>;
+  findChannelByName(name: string): Promise<ChannelRow | null>;
+};
+type CoreReads = ReturnType<typeof createCoreReads>;
+//#endregion
+export { type BundleDetail, CoreDatabase, CoreReads, CoreStorage, type KeysetInput, type ReleaseFilter, createCoreReads };