@hot-updater/protocol 0.0.0-stage → 1.0.0-rc.20

package/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2023 Sungyu Kang 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+ADDITIONAL DISCLAIMER
+
+The authors of this software shall not be held responsible for any legal issues,
+regulatory violations, policy violations, or disputes arising from the use,
+distribution, or integration of this software.
+
+Users are solely responsible for ensuring compliance with all applicable laws,
+regulations, and third-party policies (including but not limited to app store
+policies).

package/dist/index.cjs

@@ -0,0 +1,463 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/bundleArtifacts.ts
+const stripBundleArtifactMetadata = (metadata) => metadata;
+const getManifestStorageUri = (bundle) => bundle.manifestStorageUri;
+const getManifestFileHash = (bundle) => bundle.manifestFileHash;
+const getAssetBaseStorageUri = (bundle) => bundle.assetBaseStorageUri;
+const isBundlePatchArtifact = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const candidate = value;
+	return typeof candidate.baseBundleId === "string" && typeof candidate.baseFileHash === "string" && typeof candidate.patchFileHash === "string" && typeof candidate.patchStorageUri === "string";
+};
+const readBundlePatchArray = (patches) => {
+	if (!Array.isArray(patches)) return [];
+	return patches.filter(isBundlePatchArtifact);
+};
+const getBundlePatches = (bundle) => {
+	const patches = readBundlePatchArray(bundle.patches);
+	const seenBaseBundleIds = /* @__PURE__ */ new Set();
+	return patches.filter((patch) => {
+		if (seenBaseBundleIds.has(patch.baseBundleId)) return false;
+		seenBaseBundleIds.add(patch.baseBundleId);
+		return true;
+	});
+};
+const getBundlePatch = (bundle, baseBundleId) => {
+	return getBundlePatches(bundle).find((patch) => patch.baseBundleId === baseBundleId) ?? null;
+};
+const getPrimaryPatch = (bundle) => {
+	return getBundlePatches(bundle)[0] ?? null;
+};
+const getPatchBaseBundleId = (bundle) => getPrimaryPatch(bundle)?.baseBundleId ?? null;
+const getPatchBaseFileHash = (bundle) => getPrimaryPatch(bundle)?.baseFileHash ?? null;
+const getPatchFileHash = (bundle) => getPrimaryPatch(bundle)?.patchFileHash ?? null;
+const getPatchStorageUri = (bundle) => getPrimaryPatch(bundle)?.patchStorageUri ?? null;
+//#endregion
+//#region src/clientPlugin.ts
+/** Declares a client plugin; built-in and third-party plugins use the same contract. */
+const defineClientPlugin = (plugin) => plugin;
+//#endregion
+//#region src/rollout.ts
+const NUMERIC_COHORT_SIZE = 1e3;
+const DEFAULT_ROLLOUT_COHORT_COUNT = NUMERIC_COHORT_SIZE;
+const MAX_COHORT_LENGTH = 64;
+const INVALID_COHORT_ERROR_MESSAGE = `Invalid cohort. Use 1-1000 or a lowercase slug without spaces, up to 64 characters.`;
+const CUSTOM_COHORT_PATTERN = /^[a-z0-9-]+$/;
+function parseNumericCohortValue(cohort) {
+	if (!/^\d+$/.test(cohort)) return null;
+	const parsed = Number.parseInt(cohort, 10);
+	if (Number.isNaN(parsed) || parsed < 1 || parsed > 1e3) return null;
+	return parsed;
+}
+function positiveMod(value, modulus) {
+	return (value % modulus + modulus) % modulus;
+}
+function hashString(value) {
+	let hash = 0;
+	for (let i = 0; i < value.length; i++) {
+		const char = value.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash |= 0;
+	}
+	return hash;
+}
+function gcd(a, b) {
+	let x = Math.abs(a);
+	let y = Math.abs(b);
+	while (y !== 0) {
+		const next = x % y;
+		x = y;
+		y = next;
+	}
+	return x;
+}
+function modularInverse(value, modulus) {
+	let t = 0;
+	let newT = 1;
+	let r = modulus;
+	let newR = positiveMod(value, modulus);
+	while (newR !== 0) {
+		const quotient = Math.floor(r / newR);
+		[t, newT] = [newT, t - quotient * newT];
+		[r, newR] = [newR, r - quotient * newR];
+	}
+	if (r > 1) throw new Error(`No modular inverse for ${value} mod ${modulus}`);
+	return positiveMod(t, modulus);
+}
+function getRolloutShuffleParameters(bundleId) {
+	let multiplier = positiveMod(hashString(`${bundleId}:multiplier`), 997);
+	if (multiplier === 0) multiplier = 1;
+	while (gcd(multiplier, NUMERIC_COHORT_SIZE) !== 1) {
+		multiplier = positiveMod(multiplier + 1, NUMERIC_COHORT_SIZE);
+		if (multiplier === 0) multiplier = 1;
+	}
+	const offset = positiveMod(hashString(`${bundleId}:offset`), NUMERIC_COHORT_SIZE);
+	return {
+		multiplier,
+		offset,
+		inverseMultiplier: modularInverse(multiplier, NUMERIC_COHORT_SIZE)
+	};
+}
+function normalizeRolloutCohortCount(rolloutCohortCount) {
+	if (rolloutCohortCount === null || rolloutCohortCount === void 0) return DEFAULT_ROLLOUT_COHORT_COUNT;
+	if (rolloutCohortCount <= 0) return 0;
+	if (rolloutCohortCount >= 1e3) return NUMERIC_COHORT_SIZE;
+	return Math.floor(rolloutCohortCount);
+}
+function normalizeCohortValue(cohort) {
+	const normalized = cohort.trim().toLowerCase();
+	const numericCohort = parseNumericCohortValue(normalized);
+	if (numericCohort !== null) return String(numericCohort);
+	return normalized;
+}
+function getNumericCohortValue(cohort) {
+	return parseNumericCohortValue(normalizeCohortValue(cohort));
+}
+function isNumericCohort(cohort) {
+	return getNumericCohortValue(cohort) !== null;
+}
+function isCustomCohort(cohort) {
+	const normalized = normalizeCohortValue(cohort);
+	return normalized.length > 0 && normalized.length <= 64 && !/^\d+$/.test(normalized) && CUSTOM_COHORT_PATTERN.test(normalized);
+}
+function isValidCohort(cohort) {
+	const normalized = normalizeCohortValue(cohort);
+	return isNumericCohort(normalized) || isCustomCohort(normalized);
+}
+function getDefaultNumericCohort(identifier) {
+	const cohortValue = positiveMod(hashString(identifier), NUMERIC_COHORT_SIZE) + 1;
+	return String(cohortValue);
+}
+function getNumericCohortRolloutPosition(bundleId, cohortValue) {
+	if (cohortValue < 1 || cohortValue > 1e3) throw new Error(`Invalid numeric cohort: ${cohortValue}`);
+	const { offset, inverseMultiplier } = getRolloutShuffleParameters(bundleId);
+	return positiveMod(inverseMultiplier * (cohortValue - 1 - offset), NUMERIC_COHORT_SIZE);
+}
+function getRolledOutNumericCohorts(bundleId, rolloutCohortCount) {
+	const normalizedRolloutCount = normalizeRolloutCohortCount(rolloutCohortCount);
+	if (normalizedRolloutCount <= 0) return [];
+	if (normalizedRolloutCount >= 1e3) return Array.from({ length: NUMERIC_COHORT_SIZE }, (_, index) => index + 1);
+	const { multiplier, offset } = getRolloutShuffleParameters(bundleId);
+	return Array.from({ length: normalizedRolloutCount }, (_, position) => positiveMod(multiplier * position + offset, NUMERIC_COHORT_SIZE)).map((zeroBasedCohort) => zeroBasedCohort + 1).sort((left, right) => left - right);
+}
+function isCohortEligibleForUpdate(bundleId, cohort, rolloutCohortCount, targetCohorts) {
+	const normalizedCohort = cohort === null || cohort === void 0 ? void 0 : normalizeCohortValue(cohort);
+	const normalizedTargetCohorts = targetCohorts?.map((targetCohort) => normalizeCohortValue(targetCohort)) ?? [];
+	if (normalizedCohort !== void 0 && normalizedTargetCohorts.includes(normalizedCohort)) return true;
+	const normalizedRolloutCount = normalizeRolloutCohortCount(rolloutCohortCount);
+	if (normalizedRolloutCount <= 0) return false;
+	if (normalizedCohort === void 0) return normalizedRolloutCount >= NUMERIC_COHORT_SIZE;
+	const numericCohort = getNumericCohortValue(normalizedCohort);
+	if (numericCohort === null) return false;
+	if (normalizedRolloutCount >= 1e3) return true;
+	return getNumericCohortRolloutPosition(bundleId, numericCohort) < normalizedRolloutCount;
+}
+//#endregion
+//#region src/releaseCatalog.ts
+const RELEASE_CATALOG_SCHEMA_VERSION = 1;
+const RELEASE_CATALOG_FALLBACK_POLICY = "BUILTIN_IF_ACTIVE_INELIGIBLE";
+const MAX_CRASHED_BUNDLES = 10;
+const MAX_TARGET_COHORTS_PER_RELEASE = 100;
+const MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE = 512;
+const MAX_COMPILED_CATALOG_BYTES = 262144;
+const hashSelectionContext = (value) => {
+	let first = 2166136261;
+	let second = 2654435769;
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		first = Math.imul(first ^ code, 16777619);
+		second = Math.imul(second ^ code, 2246822507);
+	}
+	return `v1:${(first >>> 0).toString(16).padStart(8, "0")}${(second >>> 0).toString(16).padStart(8, "0")}`;
+};
+function createReleaseSelectionContextHash(input) {
+	const crashedBundleIds = [...new Set(input.crashedBundleIds)].sort().slice(0, 10);
+	const canonical = JSON.stringify({
+		activeBundleId: input.activeBundleId ?? null,
+		activeReleaseId: input.activeReleaseId ?? null,
+		cohort: normalizeCohortValue(input.cohort ?? ""),
+		crashedBundleIds,
+		minimumReleaseId: input.minimumReleaseId,
+		selectorSchemaVersion: 1,
+		strategy: input.strategy,
+		strategyValue: input.strategyValue
+	});
+	return hashSelectionContext(canonical);
+}
+function isReleaseEligibleForCohort(release, cohort) {
+	if (isCohortEligibleForUpdate(release.releaseId, cohort, release.rolloutCohortCount, release.targetCohorts)) return true;
+	return cohort !== null && cohort !== void 0 && isCustomCohort(normalizeCohortValue(cohort)) && normalizeRolloutCohortCount(release.rolloutCohortCount) === 1e3;
+}
+function selectDesiredRelease(catalog, input) {
+	const crashedBundleIds = new Set(input.crashedBundleIds);
+	const activeReleaseId = input.activeReleaseId ?? null;
+	const hasActiveBundle = input.currentBundleId !== input.builtInBundleId;
+	const isSafeBundleRelease = (release) => release.kind === "BUNDLE" && release.bundleId !== null && !crashedBundleIds.has(release.bundleId) && release.bundleId >= input.minimumReleaseId;
+	const desiredBundle = (release, status) => ({
+		bundleId: release.bundleId,
+		kind: "BUNDLE",
+		release,
+		releaseId: release.releaseId,
+		status
+	});
+	for (const release of catalog.releases) {
+		if (!isReleaseEligibleForCohort(release, input.cohort)) continue;
+		if (activeReleaseId !== null && release.releaseId <= activeReleaseId || activeReleaseId === null && hasActiveBundle && (release.bundleId === null || release.bundleId <= input.currentBundleId)) continue;
+		if (isSafeBundleRelease(release)) return desiredBundle(release, "UPDATE");
+		if (release.bundleId !== null) continue;
+		return {
+			bundleId: input.builtInBundleId,
+			kind: "EMBEDDED",
+			release,
+			releaseId: release.releaseId,
+			status: "ROLLBACK"
+		};
+	}
+	if (activeReleaseId !== null || hasActiveBundle) {
+		const rollbackReleases = catalog.rollbackReleases ?? catalog.releases;
+		const current = rollbackReleases.find((release) => release.releaseId === activeReleaseId || activeReleaseId === null && release.bundleId === input.currentBundleId);
+		if (current !== void 0 && isSafeBundleRelease(current) && isReleaseEligibleForCohort(current, input.cohort)) return desiredBundle(current, "UPDATE");
+		const rollback = rollbackReleases.find((release) => isSafeBundleRelease(release) && (activeReleaseId !== null ? release.releaseId < activeReleaseId : release.bundleId < input.currentBundleId));
+		if (rollback !== void 0 && isSafeBundleRelease(rollback)) return desiredBundle(rollback, "ROLLBACK");
+		if (input.currentBundleId <= input.minimumReleaseId) return null;
+	}
+	if (catalog.fallbackPolicy !== "BUILTIN_IF_ACTIVE_INELIGIBLE") return null;
+	return {
+		bundleId: input.builtInBundleId,
+		kind: "BUILTIN",
+		release: null,
+		releaseId: null,
+		status: "ROLLBACK"
+	};
+}
+function assessCatalogAcceptance(incoming, highestSeen) {
+	if (highestSeen === null) return {
+		accepted: true,
+		shouldAdvanceHighWater: true
+	};
+	if (incoming.generation < highestSeen.generation) return {
+		accepted: false,
+		reason: "STALE_GENERATION"
+	};
+	if (incoming.generation === highestSeen.generation && incoming.catalogHash !== highestSeen.catalogHash) return {
+		accepted: false,
+		reason: "GENERATION_HASH_MISMATCH"
+	};
+	return {
+		accepted: true,
+		shouldAdvanceHighWater: incoming.generation > highestSeen.generation
+	};
+}
+function authorizeReleaseTransition(input) {
+	const { active, desired, explicitScopeSwitch } = input;
+	if (active === null || active.scopeKey === null || active.generation === null) return {
+		authorized: true,
+		reason: "FIRST_AUTHENTICATED_SELECTION"
+	};
+	if (desired.catalogId !== active.catalogId || desired.scopeKey !== active.scopeKey) {
+		if (!explicitScopeSwitch) return {
+			authorized: false,
+			reason: "UNSOLICITED_SCOPE"
+		};
+		if (desired.releaseId === null || desired.kind === "BUILTIN") return {
+			authorized: false,
+			reason: "EMPTY_TARGET_SCOPE"
+		};
+		return {
+			authorized: true,
+			reason: "EXPLICIT_SCOPE_SWITCH"
+		};
+	}
+	if (desired.generation === null || desired.generation < active.generation) return {
+		authorized: false,
+		reason: "STALE_GENERATION"
+	};
+	if (desired.generation > active.generation) return {
+		authorized: true,
+		reason: "NEWER_POLICY"
+	};
+	if (desired.selectionContextHash !== active.selectionContextHash) return {
+		authorized: true,
+		reason: "CONTEXT_RESELECTION"
+	};
+	return {
+		authorized: false,
+		reason: "BACKWARD_NOT_AUTHORIZED"
+	};
+}
+//#endregion
+//#region src/releaseCatalogScope.ts
+const BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const MAX_CATALOG_SEGMENT_LENGTH = 255;
+function assertCatalogSegment(value, name) {
+	if (value.length === 0 || value.length > MAX_CATALOG_SEGMENT_LENGTH || !/^[A-Za-z0-9._~-]+$/.test(value)) throw new Error(`${name} must be 1-${MAX_CATALOG_SEGMENT_LENGTH} URL-safe ASCII characters`);
+}
+function encodeUtf8(value) {
+	const bytes = [];
+	for (const codePointText of value) {
+		const codePoint = codePointText.codePointAt(0);
+		if (codePoint <= 127) bytes.push(codePoint);
+		else if (codePoint <= 2047) bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
+		else if (codePoint <= 65535) bytes.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+		else bytes.push(240 | codePoint >> 18, 128 | codePoint >> 12 & 63, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+	}
+	return bytes;
+}
+function decodeUtf8(bytes) {
+	let result = "";
+	for (let index = 0; index < bytes.length;) {
+		const first = bytes[index++];
+		let codePoint;
+		let continuationCount;
+		if (first <= 127) {
+			codePoint = first;
+			continuationCount = 0;
+		} else if ((first & 224) === 192) {
+			codePoint = first & 31;
+			continuationCount = 1;
+		} else if ((first & 240) === 224) {
+			codePoint = first & 15;
+			continuationCount = 2;
+		} else if ((first & 248) === 240) {
+			codePoint = first & 7;
+			continuationCount = 3;
+		} else throw new Error("Invalid UTF-8 channel key");
+		for (let offset = 0; offset < continuationCount; offset += 1) {
+			const continuation = bytes[index++];
+			if (continuation === void 0 || (continuation & 192) !== 128) throw new Error("Invalid UTF-8 channel key");
+			codePoint = codePoint << 6 | continuation & 63;
+		}
+		if (codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 || continuationCount === 1 && codePoint < 128 || continuationCount === 2 && codePoint < 2048 || continuationCount === 3 && codePoint < 65536) throw new Error("Invalid UTF-8 channel key");
+		result += String.fromCodePoint(codePoint);
+	}
+	return result;
+}
+function base64UrlEncode(bytes) {
+	let result = "";
+	for (let index = 0; index < bytes.length; index += 3) {
+		const first = bytes[index];
+		const second = bytes[index + 1];
+		const third = bytes[index + 2];
+		const value = first << 16 | (second ?? 0) << 8 | (third ?? 0);
+		result += BASE64URL_ALPHABET[value >> 18 & 63];
+		result += BASE64URL_ALPHABET[value >> 12 & 63];
+		if (second !== void 0) result += BASE64URL_ALPHABET[value >> 6 & 63];
+		if (third !== void 0) result += BASE64URL_ALPHABET[value & 63];
+	}
+	return result;
+}
+function base64UrlDecode(value) {
+	if (!/^[A-Za-z0-9_-]*$/.test(value) || value.length % 4 === 1) throw new Error("Invalid channel key");
+	const bytes = [];
+	for (let index = 0; index < value.length; index += 4) {
+		const chunk = value.slice(index, index + 4);
+		const encoded = [...chunk].map((character) => BASE64URL_ALPHABET.indexOf(character));
+		if (encoded.some((part) => part < 0)) throw new Error("Invalid channel key");
+		const bits = encoded[0] << 18 | encoded[1] << 12 | (encoded[2] ?? 0) << 6 | (encoded[3] ?? 0);
+		bytes.push(bits >> 16 & 255);
+		if (chunk.length >= 3) bytes.push(bits >> 8 & 255);
+		if (chunk.length === 4) bytes.push(bits & 255);
+	}
+	return bytes;
+}
+function normalizeChannelName(channel) {
+	return channel.trim().normalize("NFC");
+}
+function assertCanonicalChannelName(channel) {
+	const normalized = normalizeChannelName(channel);
+	if (normalized.length === 0 || normalized !== channel) throw new Error("Channel name must be non-empty, trimmed, and NFC-normalized");
+	let codePointCount = 0;
+	for (const _codePoint of normalized) {
+		codePointCount += 1;
+		if (codePointCount > 255) throw new Error("Channel name must not exceed 255 characters");
+	}
+}
+function encodeChannelKey(channel) {
+	assertCanonicalChannelName(channel);
+	return base64UrlEncode(encodeUtf8(channel));
+}
+function decodeChannelKey(channelKey) {
+	const channel = decodeUtf8(base64UrlDecode(channelKey));
+	assertCanonicalChannelName(channel);
+	if (encodeChannelKey(channel) !== channelKey) throw new Error("Channel key is not canonically encoded");
+	return channel;
+}
+function createReleaseCatalogScopeKey(input) {
+	decodeChannelKey(input.channelKey);
+	if (input.strategy === "APP_VERSION") return `v1:app-version:${input.platform}:${input.channelKey}`;
+	assertCatalogSegment(input.fingerprintHash, "Fingerprint hash");
+	return `v1:fingerprint:${input.platform}:${input.channelKey}:${input.fingerprintHash}`;
+}
+function parseReleaseCatalogScopeKey(scopeKey) {
+	const segments = scopeKey.split(":");
+	const [version, strategy, platform, channelKey] = segments;
+	if (version !== "v1" || platform !== "ios" && platform !== "android" || channelKey === void 0) throw new Error("Invalid release catalog scope key");
+	const input = strategy === "app-version" && segments.length === 4 ? {
+		channelKey,
+		platform,
+		strategy: "APP_VERSION"
+	} : strategy === "fingerprint" && segments.length === 5 && segments[4] !== void 0 ? {
+		channelKey,
+		fingerprintHash: segments[4],
+		platform,
+		strategy: "FINGERPRINT"
+	} : (() => {
+		throw new Error("Invalid release catalog scope key");
+	})();
+	if (createReleaseCatalogScopeKey(input) !== scopeKey) throw new Error("Release catalog scope key is not canonical");
+	return input;
+}
+//#endregion
+//#region src/types.ts
+const ARTIFACT_PROTOCOL_VERSION = 1;
+//#endregion
+//#region src/uuid.ts
+const NIL_UUID = "00000000-0000-0000-0000-000000000000";
+const UUID_V7_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const isUUIDv7 = (value) => typeof value === "string" && UUID_V7_PATTERN.test(value);
+//#endregion
+exports.ARTIFACT_PROTOCOL_VERSION = ARTIFACT_PROTOCOL_VERSION;
+exports.DEFAULT_ROLLOUT_COHORT_COUNT = DEFAULT_ROLLOUT_COHORT_COUNT;
+exports.INVALID_COHORT_ERROR_MESSAGE = INVALID_COHORT_ERROR_MESSAGE;
+exports.MAX_COHORT_LENGTH = MAX_COHORT_LENGTH;
+exports.MAX_COMPILED_CATALOG_BYTES = MAX_COMPILED_CATALOG_BYTES;
+exports.MAX_CRASHED_BUNDLES = MAX_CRASHED_BUNDLES;
+exports.MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE = MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE;
+exports.MAX_TARGET_COHORTS_PER_RELEASE = MAX_TARGET_COHORTS_PER_RELEASE;
+exports.NIL_UUID = NIL_UUID;
+exports.NUMERIC_COHORT_SIZE = NUMERIC_COHORT_SIZE;
+exports.RELEASE_CATALOG_FALLBACK_POLICY = RELEASE_CATALOG_FALLBACK_POLICY;
+exports.RELEASE_CATALOG_SCHEMA_VERSION = RELEASE_CATALOG_SCHEMA_VERSION;
+exports.assertCanonicalChannelName = assertCanonicalChannelName;
+exports.assessCatalogAcceptance = assessCatalogAcceptance;
+exports.authorizeReleaseTransition = authorizeReleaseTransition;
+exports.createReleaseCatalogScopeKey = createReleaseCatalogScopeKey;
+exports.createReleaseSelectionContextHash = createReleaseSelectionContextHash;
+exports.decodeChannelKey = decodeChannelKey;
+exports.defineClientPlugin = defineClientPlugin;
+exports.encodeChannelKey = encodeChannelKey;
+exports.getAssetBaseStorageUri = getAssetBaseStorageUri;
+exports.getBundlePatch = getBundlePatch;
+exports.getBundlePatches = getBundlePatches;
+exports.getDefaultNumericCohort = getDefaultNumericCohort;
+exports.getManifestFileHash = getManifestFileHash;
+exports.getManifestStorageUri = getManifestStorageUri;
+exports.getNumericCohortRolloutPosition = getNumericCohortRolloutPosition;
+exports.getNumericCohortValue = getNumericCohortValue;
+exports.getPatchBaseBundleId = getPatchBaseBundleId;
+exports.getPatchBaseFileHash = getPatchBaseFileHash;
+exports.getPatchFileHash = getPatchFileHash;
+exports.getPatchStorageUri = getPatchStorageUri;
+exports.getRolledOutNumericCohorts = getRolledOutNumericCohorts;
+exports.isCohortEligibleForUpdate = isCohortEligibleForUpdate;
+exports.isCustomCohort = isCustomCohort;
+exports.isNumericCohort = isNumericCohort;
+exports.isReleaseEligibleForCohort = isReleaseEligibleForCohort;
+exports.isUUIDv7 = isUUIDv7;
+exports.isValidCohort = isValidCohort;
+exports.normalizeChannelName = normalizeChannelName;
+exports.normalizeCohortValue = normalizeCohortValue;
+exports.normalizeRolloutCohortCount = normalizeRolloutCohortCount;
+exports.parseReleaseCatalogScopeKey = parseReleaseCatalogScopeKey;
+exports.selectDesiredRelease = selectDesiredRelease;
+exports.stripBundleArtifactMetadata = stripBundleArtifactMetadata;