@hot-updater/protocol 1.1.3 → 1.2.0-rc.0

package/dist/native-artifact.mjs

@@ -0,0 +1,1090 @@
+import { l as canonicalizeAppVersion, n as isUUIDv7, o as encodeChannelKey } from "./uuid-kZvLA0Ly.mjs";
+//#region src/nativeArtifact/byteSource.ts
+/** A `Blob`, such as Node's `fs.openAsBlob`, read by slices. */
+const blobSource = (blob) => ({
+	size: blob.size,
+	async read(offset, length) {
+		return new Uint8Array(await blob.slice(offset, Math.min(blob.size, offset + length)).arrayBuffer());
+	}
+});
+/** Why an artifact can't be read, or can't serve as a native build. */
+var NativeArtifactError = class extends Error {
+	code;
+	name = "NativeArtifactError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+//#endregion
+//#region src/nativeArtifact/androidManifest.ts
+const corrupt$1 = () => new NativeArtifactError("UNREADABLE", "The artifact's AndroidManifest.xml is corrupt.");
+const view$3 = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+const RES_STRING_POOL_TYPE = 1;
+const RES_XML_TYPE = 3;
+const RES_XML_START_ELEMENT_TYPE = 258;
+const RES_XML_END_ELEMENT_TYPE = 259;
+const RES_XML_RESOURCE_MAP_TYPE = 384;
+const UTF8_FLAG = 256;
+const NO_INDEX = 4294967295;
+/** A `ResXMLTree_attrExt`, and a `ResXMLTree_attribute`, in bytes. */
+const ELEMENT_EXT_BYTES = 20;
+const ATTRIBUTE_BYTES = 20;
+/** How deep a manifest's elements nest: an AndroidManifest.xml, a few levels. */
+const MAX_ELEMENT_DEPTH = 64;
+const TYPE_REFERENCE = 1;
+const TYPE_STRING = 3;
+const TYPE_INT_DEC = 16;
+const TYPE_INT_HEX = 17;
+const TYPE_INT_BOOLEAN = 18;
+/**
+* How many bytes a manifest's strings decode to in all. A pool's offsets can
+* point many indexes, or overlapping ranges, at one long string, so the
+* manifest's own size bounds nothing.
+*/
+const DECODED_STRING_BYTES = 16777216;
+/**
+* A `ResStringPool` chunk's strings, decoded when an index is read: each
+* offset once, against one budget, within the chunk.
+*/
+const readStringPool = (bytes, start, size) => {
+	const data = view$3(bytes);
+	const end = start + size;
+	if (size < 28) throw corrupt$1();
+	const count = data.getUint32(start + 8, true);
+	const flags = data.getUint32(start + 16, true);
+	const stringsStart = start + data.getUint32(start + 20, true);
+	if (start + 28 + count * 4 > end || stringsStart > end) throw corrupt$1();
+	const utf8 = (flags & UTF8_FLAG) !== 0;
+	const decoder = new TextDecoder(utf8 ? "utf-8" : "utf-16le");
+	const decoded = /* @__PURE__ */ new Map();
+	let budget = DECODED_STRING_BYTES;
+	return (index) => {
+		if (index === NO_INDEX || index >= count) return "";
+		const offset = data.getUint32(start + 28 + index * 4, true);
+		const known = decoded.get(offset);
+		if (known !== void 0) return known;
+		let at = stringsStart + offset;
+		let byteLength;
+		if (at + 4 > end) throw corrupt$1();
+		if (utf8) {
+			at += bytes[at] & 128 ? 2 : 1;
+			let length = bytes[at];
+			if (length & 128) {
+				length = (length & 127) << 8 | bytes[at + 1];
+				at += 2;
+			} else at += 1;
+			byteLength = length;
+		} else {
+			let length = data.getUint16(at, true);
+			if (length & 32768) {
+				length = (length & 32767) << 16 | data.getUint16(at + 2, true);
+				at += 4;
+			} else at += 2;
+			byteLength = length * 2;
+		}
+		budget -= byteLength;
+		if (at + byteLength > end || budget < 0) throw corrupt$1();
+		const text = decoder.decode(bytes.subarray(at, at + byteLength));
+		decoded.set(offset, text);
+		return text;
+	};
+};
+const parseBinaryManifest = (bytes) => {
+	const data = view$3(bytes);
+	if (bytes.byteLength < 8 || data.getUint16(0, true) !== RES_XML_TYPE) throw corrupt$1();
+	let stringAt = () => "";
+	let resourceIds = [];
+	const stack = [];
+	let root = null;
+	for (let at = data.getUint16(2, true); at + 8 <= bytes.byteLength;) {
+		const type = data.getUint16(at, true);
+		const headerSize = data.getUint16(at + 2, true);
+		const size = data.getUint32(at + 4, true);
+		if (size < 8 || at + size > bytes.byteLength) throw corrupt$1();
+		if (type === RES_STRING_POOL_TYPE) stringAt = readStringPool(bytes, at, size);
+		else if (type === RES_XML_RESOURCE_MAP_TYPE) {
+			resourceIds = [];
+			for (let i = at + headerSize; i + 4 <= at + size; i += 4) resourceIds.push(data.getUint32(i, true));
+		} else if (type === RES_XML_START_ELEMENT_TYPE) {
+			const ext = at + headerSize;
+			const attributeStart = data.getUint16(ext + 8, true);
+			const attributeSize = data.getUint16(ext + 10, true);
+			const attributeCount = data.getUint16(ext + 12, true);
+			if (headerSize < 16 || ext + ELEMENT_EXT_BYTES > at + size || attributeStart < ELEMENT_EXT_BYTES || attributeSize < ATTRIBUTE_BYTES || ext + attributeStart + attributeCount * attributeSize > at + size || stack.length >= MAX_ELEMENT_DEPTH) throw corrupt$1();
+			const name = stringAt(data.getUint32(ext + 4, true));
+			const attributes = [];
+			for (let i = 0; i < attributeCount; i += 1) {
+				const attr = ext + attributeStart + i * attributeSize;
+				const nameIndex = data.getUint32(attr + 4, true);
+				const raw = data.getUint32(attr + 8, true);
+				const dataType = bytes[attr + 15];
+				const value = data.getUint32(attr + 16, true);
+				attributes.push({
+					name: stringAt(nameIndex),
+					resourceId: resourceIds[nameIndex] ?? 0,
+					value: dataType === TYPE_STRING ? {
+						type: "string",
+						value: stringAt(raw === NO_INDEX ? value : raw)
+					} : dataType === TYPE_INT_BOOLEAN ? {
+						type: "boolean",
+						value: value !== 0
+					} : dataType === TYPE_INT_DEC || dataType === TYPE_INT_HEX ? {
+						type: "int",
+						value: value | 0
+					} : dataType === TYPE_REFERENCE ? {
+						type: "reference",
+						id: value
+					} : { type: "other" }
+				});
+			}
+			stack.push({
+				name,
+				attributes,
+				children: []
+			});
+		} else if (type === RES_XML_END_ELEMENT_TYPE) {
+			const element = stack.pop();
+			if (element === void 0) throw corrupt$1();
+			const parent = stack.at(-1);
+			if (parent === void 0) root ??= element;
+			else parent.children.push(element);
+		}
+		at += size;
+	}
+	if (root === null) throw corrupt$1();
+	return root;
+};
+/** A minimal protobuf reader: fields of one message, by number. */
+const readMessage = (bytes) => {
+	const fields = [];
+	let at = 0;
+	const varint = () => {
+		let value = 0;
+		let multiplier = 1;
+		for (;;) {
+			if (at >= bytes.byteLength) throw corrupt$1();
+			const byte = bytes[at++];
+			value += (byte & 127) * multiplier;
+			if ((byte & 128) === 0) return value;
+			multiplier *= 128;
+			if (multiplier > 2 ** 63) throw corrupt$1();
+		}
+	};
+	while (at < bytes.byteLength) {
+		const key = varint();
+		const field = Math.floor(key / 8);
+		const wireType = key % 8;
+		if (wireType === 0) fields.push({
+			field,
+			wireType,
+			value: varint()
+		});
+		else if (wireType === 2) {
+			const length = varint();
+			if (at + length > bytes.byteLength) throw corrupt$1();
+			fields.push({
+				field,
+				wireType,
+				value: bytes.subarray(at, at + length)
+			});
+			at += length;
+		} else if (wireType === 5) at += 4;
+		else if (wireType === 1) at += 8;
+		else throw corrupt$1();
+	}
+	return fields;
+};
+const decoder = new TextDecoder();
+const bytesOf = (fields, field) => fields.filter((f) => f.field === field && f.value instanceof Uint8Array).map((f) => f.value);
+const stringOf = (fields, field) => {
+	const [value] = bytesOf(fields, field);
+	return value === void 0 ? "" : decoder.decode(value);
+};
+const numberOf = (fields, field) => {
+	const found = fields.find((f) => f.field === field && f.wireType === 0);
+	return found === void 0 ? void 0 : found.value;
+};
+/** An `Item` of aapt2's Resources.proto, as an attribute's compiled value. */
+const protoItemValue = (item, raw) => {
+	const fields = readMessage(item);
+	const [reference] = bytesOf(fields, 1);
+	if (reference !== void 0) {
+		const ref = readMessage(reference);
+		return {
+			type: "reference",
+			id: numberOf(ref, 2) ?? 0,
+			name: stringOf(ref, 3) || void 0
+		};
+	}
+	const [str] = bytesOf(fields, 2);
+	if (str !== void 0) return {
+		type: "string",
+		value: stringOf(readMessage(str), 1)
+	};
+	const [primitive] = bytesOf(fields, 7);
+	if (primitive !== void 0) {
+		const prim = readMessage(primitive);
+		const boolean = numberOf(prim, 8);
+		if (boolean !== void 0) return {
+			type: "boolean",
+			value: boolean !== 0
+		};
+		const int = numberOf(prim, 6) ?? numberOf(prim, 7);
+		if (int !== void 0) return {
+			type: "int",
+			value: int | 0
+		};
+		if (raw !== "") return {
+			type: "string",
+			value: raw
+		};
+	}
+	return null;
+};
+/** An `XmlElement` of aapt2's Resources.proto. */
+const protoElement = (bytes, depth = 0) => {
+	if (depth >= MAX_ELEMENT_DEPTH) throw corrupt$1();
+	const fields = readMessage(bytes);
+	const attributes = bytesOf(fields, 4).map((attribute) => {
+		const attr = readMessage(attribute);
+		const raw = stringOf(attr, 3);
+		const [item] = bytesOf(attr, 6);
+		return {
+			name: stringOf(attr, 2),
+			resourceId: numberOf(attr, 5) ?? 0,
+			value: (item && protoItemValue(item, raw)) ?? {
+				type: "string",
+				value: raw
+			}
+		};
+	});
+	const children = bytesOf(fields, 5).flatMap((node) => {
+		const [element] = bytesOf(readMessage(node), 1);
+		return element === void 0 ? [] : [protoElement(element, depth + 1)];
+	});
+	return {
+		name: stringOf(fields, 3),
+		attributes,
+		children
+	};
+};
+/**
+* An `.aab` module's `manifest/AndroidManifest.xml`, an `XmlNode` of
+* aapt2's Resources.proto.
+*/
+const parseProtoManifest = (bytes) => {
+	const [element] = bytesOf(readMessage(bytes), 1);
+	if (element === void 0) throw corrupt$1();
+	return protoElement(element);
+};
+const VERSION_CODE = 16843291;
+const VERSION_NAME = 16843292;
+const NAME = 16842755;
+const VALUE = 16842788;
+const RESOURCE = 16842789;
+const attributeOf = (element, resourceId, name) => element.attributes.find((attribute) => attribute.resourceId !== 0 ? attribute.resourceId === resourceId : attribute.name === name)?.value ?? null;
+/** The values of a parsed manifest that import reads. */
+const readAndroidManifest = (manifest) => {
+	if (manifest.name !== "manifest") throw corrupt$1();
+	const packageValue = manifest.attributes.find((attribute) => attribute.name === "package")?.value;
+	const versionCode = attributeOf(manifest, VERSION_CODE, "versionCode");
+	const application = manifest.children.find(({ name }) => name === "application");
+	const metaData = /* @__PURE__ */ new Map();
+	for (const element of application?.children ?? []) {
+		if (element.name !== "meta-data") continue;
+		const name = attributeOf(element, NAME, "name");
+		const value = attributeOf(element, VALUE, "value") ?? attributeOf(element, RESOURCE, "resource");
+		if (name?.type === "string" && value !== null) metaData.set(name.value, value);
+	}
+	return {
+		packageName: packageValue?.type === "string" ? packageValue.value : null,
+		versionName: attributeOf(manifest, VERSION_NAME, "versionName"),
+		versionCode: versionCode?.type === "int" ? versionCode.value : null,
+		metaData
+	};
+};
+//#endregion
+//#region src/nativeArtifact/plist.ts
+/** How deep a plist nests: an Info.plist nests a few levels. */
+const MAX_DEPTH = 64;
+const corrupt = () => new NativeArtifactError("UNREADABLE", "The app's Info.plist is corrupt.");
+const view$2 = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+/** A big-endian unsigned integer of `size` bytes. */
+const uintAt = (bytes, offset, size) => {
+	let value = 0;
+	for (let i = 0; i < size; i += 1) value = value * 256 + bytes[offset + i];
+	return value;
+};
+/** A binary property list (`bplist00`), as Xcode writes an app's Info.plist. */
+const parseBinaryPlist = (bytes) => {
+	if (bytes.byteLength < 40) throw corrupt();
+	const trailer = bytes.byteLength - 32;
+	const offsetSize = bytes[trailer + 6];
+	const refSize = bytes[trailer + 7];
+	const objectCount = uintAt(bytes, trailer + 8, 8);
+	const top = uintAt(bytes, trailer + 16, 8);
+	const tableOffset = uintAt(bytes, trailer + 24, 8);
+	if (offsetSize < 1 || offsetSize > 8 || refSize < 1 || refSize > 8 || objectCount < 1 || top >= objectCount || tableOffset < 8 || tableOffset + objectCount * offsetSize > trailer) throw corrupt();
+	const data = view$2(bytes);
+	const seen = /* @__PURE__ */ new Set();
+	const parsed = /* @__PURE__ */ new Map();
+	let budget = 2 * bytes.byteLength + 4096;
+	const spend = (units) => {
+		budget -= units;
+		if (budget < 0) throw corrupt();
+	};
+	const parse = (ref) => {
+		if (ref >= objectCount) throw corrupt();
+		const offset = uintAt(bytes, tableOffset + ref * offsetSize, offsetSize);
+		if (offset < 8 || offset >= tableOffset) throw corrupt();
+		const done = parsed.get(offset);
+		if (done !== void 0) return done;
+		if (seen.has(offset) || seen.size > MAX_DEPTH) throw corrupt();
+		const value = parseObject(offset);
+		parsed.set(offset, value);
+		return value;
+	};
+	const parseObject = (offset) => {
+		const marker = bytes[offset];
+		const kind = marker >> 4;
+		const info = marker & 15;
+		/** `count` units of `unit` bytes from `start`, which must fit the objects. */
+		const fits = (start, count, unit) => {
+			if (start + count * unit > tableOffset) throw corrupt();
+		};
+		/**
+		* A length in the marker, or in the integer object after it, and where
+		* its `unit`-byte items start, all of which must fit the objects.
+		*/
+		const lengthAt = (unit) => {
+			let length = info;
+			let start = offset + 1;
+			if (info === 15) {
+				const sizeMarker = bytes[offset + 1];
+				if (sizeMarker >> 4 !== 1 || (sizeMarker & 15) > 3) throw corrupt();
+				const size = 1 << (sizeMarker & 15);
+				fits(offset + 2, size, 1);
+				length = uintAt(bytes, offset + 2, size);
+				start = offset + 2 + size;
+			}
+			fits(start, length, unit);
+			spend(length + 1);
+			return [length, start];
+		};
+		switch (kind) {
+			case 0: return info === 9 ? true : info === 8 ? false : null;
+			case 1: {
+				if (info > 3) throw corrupt();
+				const size = 1 << info;
+				fits(offset + 1, size, 1);
+				return size === 8 ? Number(data.getBigInt64(offset + 1, false)) : uintAt(bytes, offset + 1, size);
+			}
+			case 2:
+				if (info !== 2 && info !== 3) throw corrupt();
+				fits(offset + 1, 1 << info, 1);
+				return info === 2 ? data.getFloat32(offset + 1, false) : data.getFloat64(offset + 1, false);
+			case 3:
+				fits(offset + 1, 8, 1);
+				return data.getFloat64(offset + 1, false);
+			case 4: {
+				const [length, start] = lengthAt(1);
+				return bytes.slice(start, start + length);
+			}
+			case 5: {
+				const [length, start] = lengthAt(1);
+				return new TextDecoder("latin1").decode(bytes.subarray(start, start + length));
+			}
+			case 6: {
+				const [length, start] = lengthAt(2);
+				let text = "";
+				for (let i = 0; i < length; i += 1) text += String.fromCharCode(data.getUint16(start + i * 2, false));
+				return text;
+			}
+			case 8:
+				if (info > 7) throw corrupt();
+				fits(offset + 1, info + 1, 1);
+				return uintAt(bytes, offset + 1, info + 1);
+			case 10:
+			case 12: {
+				const [length, start] = lengthAt(refSize);
+				seen.add(offset);
+				const items = [];
+				for (let i = 0; i < length; i += 1) items.push(parse(uintAt(bytes, start + i * refSize, refSize)));
+				seen.delete(offset);
+				return items;
+			}
+			case 13: {
+				const [length, start] = lengthAt(2 * refSize);
+				seen.add(offset);
+				const dict = Object.create(null);
+				for (let i = 0; i < length; i += 1) {
+					const key = parse(uintAt(bytes, start + i * refSize, refSize));
+					const value = parse(uintAt(bytes, start + (length + i) * refSize, refSize));
+					if (typeof key !== "string") throw corrupt();
+					dict[key] = value;
+				}
+				seen.delete(offset);
+				return dict;
+			}
+			default: throw corrupt();
+		}
+	};
+	return parse(top);
+};
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+const decodeEntities = (text) => text.replace(/&(#x[0-9a-f]+|#\d+|\w+);/giu, (whole, entity) => {
+	if (entity[0] === "#") {
+		const code = entity[1] === "x" || entity[1] === "X" ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
+		return String.fromCodePoint(code);
+	}
+	return ENTITIES[entity] ?? whole;
+});
+/** An XML property list, as some tools leave an app's Info.plist. */
+const parseXmlPlist = (text) => {
+	const tokens = text.replace(/<!--[\s\S]*?-->/gu, "").replace(/<\?[\s\S]*?\?>/gu, "").replace(/<!DOCTYPE[^>]*>/giu, "").split(/(<[^>]+>)/u);
+	let i = 0;
+	const nextTag = () => {
+		while (i < tokens.length) {
+			const token = tokens[i++];
+			if (token.startsWith("<")) return token;
+			if (token.trim() !== "") throw corrupt();
+		}
+		throw corrupt();
+	};
+	const textUntil = (close) => {
+		let value = "";
+		while (i < tokens.length && tokens[i] !== close) value += tokens[i++];
+		if (tokens[i++] !== close) throw corrupt();
+		return decodeEntities(value);
+	};
+	let depth = 0;
+	const parseValue = (tag) => {
+		if (depth > MAX_DEPTH) throw corrupt();
+		const name = /^<\s*([\w]+)/u.exec(tag)?.[1];
+		const empty = tag.endsWith("/>");
+		switch (name) {
+			case "string": return empty ? "" : textUntil("</string>");
+			case "integer": return Number(textUntil("</integer>"));
+			case "real": return Number(textUntil("</real>"));
+			case "true": return true;
+			case "false": return false;
+			case "date": return textUntil("</date>");
+			case "data": return textUntil("</data>").replace(/\s+/gu, "");
+			case "array": {
+				const items = [];
+				if (empty) return items;
+				depth += 1;
+				for (let next = nextTag(); next !== "</array>"; next = nextTag()) items.push(parseValue(next));
+				depth -= 1;
+				return items;
+			}
+			case "dict": {
+				const dict = Object.create(null);
+				if (empty) return dict;
+				depth += 1;
+				for (let next = nextTag(); next !== "</dict>"; next = nextTag()) {
+					if (next !== "<key>") throw corrupt();
+					const key = textUntil("</key>");
+					dict[key] = parseValue(nextTag());
+				}
+				depth -= 1;
+				return dict;
+			}
+			default: throw corrupt();
+		}
+	};
+	let tag = nextTag();
+	if (/^<plist\b/u.test(tag)) tag = nextTag();
+	return parseValue(tag);
+};
+/** A property list, binary or XML, as a JavaScript value. */
+const parsePlist = (bytes) => {
+	if (new TextDecoder().decode(bytes.subarray(0, 8)) === "bplist00") return parseBinaryPlist(bytes);
+	return parseXmlPlist(new TextDecoder().decode(bytes));
+};
+//#endregion
+//#region src/nativeArtifact/strings.ts
+const view$1 = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+/** Bytes that are all ASCII, as text; null otherwise. */
+const asciiOf = (bytes) => {
+	let text = "";
+	for (const byte of bytes) {
+		if (byte === 0 || byte >= 128) return null;
+		text += String.fromCharCode(byte);
+	}
+	return text;
+};
+/**
+* The string constants of a dex file with one of `lengths`, from its string
+* pool: every string literal the app's code holds, each one whole. R8
+* renames and inlines classes, but never drops a literal the code returns,
+* so the pool still holds a value the native SDK compiled in.
+*/
+const readDexStrings = (dex, lengths) => {
+	const data = view$1(dex);
+	if (dex.byteLength < 112 || asciiOf(dex.subarray(0, 3)) !== "dex" || dex[3] !== 10) throw new NativeArtifactError("UNREADABLE", "A dex file is corrupt.");
+	const count = data.getUint32(56, true);
+	const idsOffset = data.getUint32(60, true);
+	if (idsOffset + count * 4 > dex.byteLength) throw new NativeArtifactError("UNREADABLE", "A dex file is corrupt.");
+	const strings = [];
+	const read = /* @__PURE__ */ new Set();
+	for (let i = 0; i < count; i += 1) {
+		let offset = data.getUint32(idsOffset + i * 4, true);
+		if (read.has(offset)) continue;
+		read.add(offset);
+		let utf16Length = 0;
+		for (let shift = 0; offset < dex.byteLength; shift += 7) {
+			const byte = dex[offset++];
+			utf16Length |= (byte & 127) << shift;
+			if ((byte & 128) === 0 || shift > 28) break;
+		}
+		if (!lengths.has(utf16Length)) continue;
+		const end = offset + utf16Length;
+		if (end >= dex.byteLength || dex[end] !== 0) continue;
+		const text = asciiOf(dex.subarray(offset, end));
+		if (text !== null) strings.push(text);
+	}
+	return strings;
+};
+const MH_MAGIC = 4277009102;
+const MH_MAGIC_64 = 4277009103;
+const FAT_MAGIC = 3405691582;
+const FAT_MAGIC_64 = 3405691583;
+const LC_SEGMENT = 1;
+const LC_SEGMENT_64 = 25;
+const CPU_TYPE_ARM64 = 16777228;
+const nameAt = (bytes, offset) => {
+	let name = "";
+	for (let i = offset; i < offset + 16 && bytes[i] !== 0; i += 1) name += String.fromCharCode(bytes[i]);
+	return name;
+};
+/** The slice of a universal binary to read: arm64's, else the first. */
+const sliceOf = async (read) => {
+	const head = await read(0, 4096);
+	if (head.byteLength < 8) return null;
+	const data = view$1(head);
+	const magic = data.getUint32(0, false);
+	if (magic !== FAT_MAGIC && magic !== FAT_MAGIC_64) return 0;
+	const count = data.getUint32(4, false);
+	const size = magic === FAT_MAGIC ? 20 : 32;
+	let first = null;
+	for (let i = 0; i < count && 8 + (i + 1) * size <= head.byteLength; i += 1) {
+		const at = 8 + i * size;
+		const offset = magic === FAT_MAGIC ? data.getUint32(at + 8, false) : Number(data.getBigUint64(at + 8, false));
+		if (data.getUint32(at, false) === CPU_TYPE_ARM64) return offset;
+		first ??= offset;
+	}
+	return first;
+};
+/**
+* The C string literals of a Mach-O binary with one of `lengths`, from its
+* `__TEXT,__cstring` section, each one whole: the literals an Objective-C or
+* Swift source compiled in. A universal binary is read by its arm64 slice.
+* A file that is no Mach-O binary holds none.
+*/
+const readMachOStrings = async (read, lengths) => {
+	const base = await sliceOf(read);
+	if (base === null) return [];
+	const header = await read(base, base + 32);
+	if (header.byteLength < 28) return [];
+	const data = view$1(header);
+	const magic = data.getUint32(0, true);
+	if (magic !== MH_MAGIC && magic !== MH_MAGIC_64) return [];
+	const is64 = magic === MH_MAGIC_64;
+	const headerSize = is64 ? 32 : 28;
+	const commandCount = data.getUint32(16, true);
+	const commandsSize = data.getUint32(20, true);
+	const commands = await read(base + headerSize, base + headerSize + commandsSize);
+	const cmds = view$1(commands);
+	let section = null;
+	for (let i = 0, at = 0; i < commandCount && at + 8 <= commands.byteLength && section === null; i += 1) {
+		const cmd = cmds.getUint32(at, true);
+		const cmdSize = cmds.getUint32(at + 4, true);
+		if (cmdSize < 8) break;
+		if ((cmd === LC_SEGMENT_64 || cmd === LC_SEGMENT) && nameAt(commands, at + 8) === "__TEXT") {
+			const sectionCount = cmds.getUint32(at + (is64 ? 64 : 48), true);
+			const first = at + (is64 ? 72 : 56);
+			const sectionSize = is64 ? 80 : 68;
+			for (let s = 0; s < sectionCount; s += 1) {
+				const sec = first + s * sectionSize;
+				if (sec + sectionSize > commands.byteLength) break;
+				if (nameAt(commands, sec) !== "__cstring") continue;
+				section = is64 ? {
+					size: Number(cmds.getBigUint64(sec + 40, true)),
+					offset: cmds.getUint32(sec + 48, true)
+				} : {
+					size: cmds.getUint32(sec + 36, true),
+					offset: cmds.getUint32(sec + 40, true)
+				};
+				break;
+			}
+		}
+		at += cmdSize;
+	}
+	if (section === null || section.size === 0) return [];
+	const cstrings = await read(base + section.offset, base + section.offset + section.size);
+	const strings = [];
+	for (let start = 0; start < cstrings.byteLength;) {
+		let end = cstrings.indexOf(0, start);
+		if (end === -1) end = cstrings.byteLength;
+		if (lengths.has(end - start)) {
+			const text = asciiOf(cstrings.subarray(start, end));
+			if (text !== null) strings.push(text);
+		}
+		start = end + 1;
+	}
+	return strings;
+};
+//#endregion
+//#region src/nativeArtifact/zip.ts
+const EOCD_SIGNATURE = 101010256;
+const ZIP64_EOCD_LOCATOR_SIGNATURE = 117853008;
+const ZIP64_EOCD_SIGNATURE = 101075792;
+const CENTRAL_HEADER_SIGNATURE = 33639248;
+const LOCAL_HEADER_SIGNATURE = 67324752;
+const ZIP64_EXTRA_ID = 1;
+const UINT32_MAX = 4294967295;
+/** The end-of-central-directory record and the longest comment after it. */
+const EOCD_SEARCH_LENGTH = 65557;
+/** How much compressed data one read takes. */
+const READ_CHUNK = 1048576;
+const MiB$1 = 1048576;
+/**
+* What an archive may hold before it is refused as no artifact: an upload is
+* untrusted, so a crafted directory or entry (a zip bomb) stops here, not
+* after filling memory.
+*/
+const ZIP_LIMITS = {
+	/** The central directory. */
+	directoryBytes: 64 * MiB$1,
+	entries: 5e5,
+	/** An entry streamed out whole, such as the built-in bundle. */
+	entryBytes: 1024 * MiB$1
+};
+const UNIX_HOST = 3;
+const S_IFMT = 61440;
+const S_IFLNK = 40960;
+const view = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+const notZip = () => new NativeArtifactError("UNREADABLE", "The file is not a zip archive, as an .ipa, .aab or .apk is.");
+const u64 = (data, offset) => Number(data.getBigUint64(offset, true));
+/** The central directory's offset and size, from its end record (ZIP64 too). */
+const centralDirectoryOf = async (source) => {
+	const start = Math.max(0, source.size - EOCD_SEARCH_LENGTH);
+	const tail = await source.read(start, source.size - start);
+	const data = view(tail);
+	for (let i = tail.length - 22; i >= 0; i -= 1) {
+		if (data.getUint32(i, true) !== EOCD_SIGNATURE) continue;
+		let size = data.getUint32(i + 12, true);
+		let offset = data.getUint32(i + 16, true);
+		if (offset === UINT32_MAX || size === UINT32_MAX) {
+			const locator = i - 20;
+			if (locator < 0 || data.getUint32(locator, true) !== ZIP64_EOCD_LOCATOR_SIGNATURE) throw notZip();
+			const record = view(await source.read(u64(data, locator + 8), 56));
+			if (record.byteLength < 56 || record.getUint32(0, true) !== ZIP64_EOCD_SIGNATURE) throw notZip();
+			size = u64(record, 40);
+			offset = u64(record, 48);
+		}
+		if (offset + size > source.size) throw notZip();
+		return {
+			offset,
+			size
+		};
+	}
+	throw notZip();
+};
+/** Every entry of a zip archive, reading only its central directory. */
+const readZipDirectory = async (source) => {
+	const { offset, size } = await centralDirectoryOf(source);
+	if (size > ZIP_LIMITS.directoryBytes) throw new NativeArtifactError("UNREADABLE", "The archive's directory is larger than any artifact's.");
+	const directory = await source.read(offset, size);
+	const data = view(directory);
+	const decoder = new TextDecoder();
+	const entries = [];
+	for (let i = 0; i + 46 <= directory.length;) {
+		if (data.getUint32(i, true) !== CENTRAL_HEADER_SIGNATURE) break;
+		if (entries.length >= ZIP_LIMITS.entries) throw new NativeArtifactError("UNREADABLE", "The archive holds more entries than any artifact.");
+		const madeBy = data.getUint16(i + 4, true);
+		const externalAttributes = data.getUint32(i + 38, true);
+		const method = data.getUint16(i + 10, true);
+		let compressedSize = data.getUint32(i + 20, true);
+		let uncompressedSize = data.getUint32(i + 24, true);
+		const nameLength = data.getUint16(i + 28, true);
+		const extraLength = data.getUint16(i + 30, true);
+		const commentLength = data.getUint16(i + 32, true);
+		let localHeaderOffset = data.getUint32(i + 42, true);
+		const nameStart = i + 46;
+		const name = decoder.decode(directory.subarray(nameStart, nameStart + nameLength));
+		const extraStart = nameStart + nameLength;
+		for (let j = extraStart; j + 4 <= extraStart + extraLength;) {
+			const id = data.getUint16(j, true);
+			const length = data.getUint16(j + 2, true);
+			if (id === ZIP64_EXTRA_ID) {
+				let k = j + 4;
+				if (uncompressedSize === UINT32_MAX) {
+					uncompressedSize = u64(data, k);
+					k += 8;
+				}
+				if (compressedSize === UINT32_MAX) {
+					compressedSize = u64(data, k);
+					k += 8;
+				}
+				if (localHeaderOffset === UINT32_MAX) localHeaderOffset = u64(data, k);
+			}
+			j += 4 + length;
+		}
+		const segments = name.split("/");
+		entries.push({
+			name,
+			unsafe: name.startsWith("/") || /^[A-Za-z]:/u.test(name) || name.includes("\\") || name.includes("\0") || segments.includes(".."),
+			symlink: madeBy >> 8 === UNIX_HOST && (externalAttributes >>> 16 & S_IFMT) === S_IFLNK,
+			method,
+			compressedSize,
+			uncompressedSize,
+			localHeaderOffset
+		});
+		i = extraStart + extraLength + commentLength;
+	}
+	return entries;
+};
+/**
+* The one entry an artifact's reader takes by `name`: a symbolic link, or a
+* name the archive holds twice, which could hand the reader other bytes
+* than an installer reads, is refused. Unsafe names match nothing.
+*/
+const findZipEntry = (entries, match) => {
+	const test = typeof match === "string" ? (name) => name === match : match;
+	const found = entries.filter(({ name, unsafe }) => !unsafe && test(name));
+	for (const entry of found) assertReadable(entry);
+	if (typeof match === "string" && found.length > 1) throw new NativeArtifactError("UNREADABLE", `The archive holds ${match} more than once.`);
+	return found[0];
+};
+/** Every safe entry `match` takes, each a file the reader may read. */
+const filterZipEntries = (entries, match) => {
+	const found = entries.filter(({ name, unsafe }) => !unsafe && match(name));
+	for (const entry of found) assertReadable(entry);
+	return found;
+};
+const assertReadable = (entry) => {
+	if (entry.symlink) throw new NativeArtifactError("UNREADABLE", `The archive's ${entry.name} is a symbolic link, not a file.`);
+};
+const tooLarge = (entry, limit) => new NativeArtifactError("UNREADABLE", `The archive's ${entry.name} is larger than ${Math.round(limit / MiB$1)} MB, more than any artifact's.`);
+/** Where an entry's data starts, past its local header. */
+const dataOffsetOf = async (source, entry) => {
+	const local = view(await source.read(entry.localHeaderOffset, 30));
+	if (local.byteLength < 30 || local.getUint32(0, true) !== LOCAL_HEADER_SIGNATURE) throw new NativeArtifactError("UNREADABLE", `The archive's ${entry.name} is corrupt.`);
+	return entry.localHeaderOffset + 30 + local.getUint16(26, true) + local.getUint16(28, true);
+};
+/**
+* An entry's uncompressed bytes as a stream, read from the source a chunk at
+* a time, so a large entry is never held whole.
+*/
+const openZipEntry = async (source, entry, { maxBytes = ZIP_LIMITS.entryBytes } = {}) => {
+	assertReadable(entry);
+	if (entry.unsafe) throw new NativeArtifactError("UNREADABLE", `The archive's entry ${JSON.stringify(entry.name)} has a name no artifact holds.`);
+	if (entry.uncompressedSize > maxBytes) throw tooLarge(entry, maxBytes);
+	if (entry.method !== 0 && entry.method !== 8) throw new NativeArtifactError("UNREADABLE", `The archive stores ${entry.name} with an unsupported compression method (${entry.method}).`);
+	const start = await dataOffsetOf(source, entry);
+	const end = start + entry.compressedSize;
+	let position = start;
+	const compressed = new ReadableStream({ async pull(controller) {
+		if (position >= end) {
+			controller.close();
+			return;
+		}
+		const chunk = await source.read(position, Math.min(READ_CHUNK, end - position));
+		if (chunk.byteLength === 0) {
+			controller.error(new NativeArtifactError("UNREADABLE", `The archive ends inside ${entry.name}.`));
+			return;
+		}
+		position += chunk.byteLength;
+		controller.enqueue(chunk);
+	} });
+	const inflated = entry.method === 0 ? compressed : compressed.pipeThrough(new DecompressionStream("deflate-raw"));
+	const limit = Math.min(entry.uncompressedSize, maxBytes);
+	let produced = 0;
+	return inflated.pipeThrough(new TransformStream({ transform(chunk, controller) {
+		produced += chunk.byteLength;
+		if (produced > limit) {
+			controller.error(new NativeArtifactError("UNREADABLE", `The archive's ${entry.name} inflates past the size it declares.`));
+			return;
+		}
+		controller.enqueue(chunk);
+	} }));
+};
+/**
+* The uncompressed bytes in `[start, end)` of an entry, which stops
+* inflating once it has them: a Mach-O header without the rest of the
+* binary.
+*/
+const readZipEntryRange = async (source, entry, start, end, budget) => {
+	const length = Math.max(0, Math.min(end, entry.uncompressedSize) - start);
+	if (budget !== void 0 && start + length > budget.remaining) throw new NativeArtifactError("UNREADABLE", "The artifact inflates to more than any artifact's.");
+	const out = new Uint8Array(length);
+	if (length === 0) return out;
+	const reader = (await openZipEntry(source, entry)).getReader();
+	let position = 0;
+	let written = 0;
+	try {
+		while (written < length) {
+			if (budget !== void 0 && Date.now() > budget.deadline) throw new NativeArtifactError("UNREADABLE", "Reading the artifact took too long.");
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (budget !== void 0) budget.remaining -= value.byteLength;
+			const from = Math.max(start - position, 0);
+			const to = Math.min(start + length - position, value.byteLength);
+			if (from < to) {
+				out.set(value.subarray(from, to), position + from - start);
+				written += to - from;
+			}
+			position += value.byteLength;
+		}
+	} catch (error) {
+		throw error instanceof NativeArtifactError ? error : new NativeArtifactError("UNREADABLE", `The archive's ${entry.name} can't be decompressed: ${error instanceof Error ? error.message : String(error)}.`);
+	} finally {
+		await reader.cancel().catch(() => {});
+	}
+	return written === length ? out : out.subarray(0, written);
+};
+/** An entry's uncompressed bytes, refused past `maxBytes`. */
+const readZipEntry = (source, entry, maxBytes, budget) => {
+	if (entry.uncompressedSize > maxBytes) throw tooLarge(entry, maxBytes);
+	return readZipEntryRange(source, entry, 0, entry.uncompressedSize, budget);
+};
+//#endregion
+//#region src/nativeArtifact/readNativeArtifact.ts
+const MiB = 1048576;
+/** The most a manifest or an Info.plist holds. */
+const METADATA_BYTES = 16 * MiB;
+/** The most one dex file holds. */
+const DEX_BYTES = 256 * MiB;
+/** The most reading one artifact inflates, across every entry it reads. */
+const READ_BUDGET_BYTES = 2048 * MiB;
+/** How long reading one artifact may take. */
+const DEFAULT_TIMEOUT_MS = 12e4;
+/** Where each kind of artifact packs its built-in bundle. */
+const builtInBundlePathOf = (kind, appDirectory = kind === "app" ? "<App>.app/" : "Payload/<App>.app/") => kind === "aab" ? "base/assets/index.android.bundle" : kind === "apk" ? "assets/index.android.bundle" : `${appDirectory}main.jsbundle`;
+/** The kind of artifact a file name names, or null. */
+const nativeArtifactKindOf = (fileName) => {
+	if (/\.app\.zip$/iu.test(fileName)) return "app";
+	const extension = /\.([^./\\]+)$/u.exec(fileName)?.[1]?.toLowerCase();
+	return extension === "ipa" || extension === "aab" || extension === "apk" ? extension : null;
+};
+const UUID_LENGTH = 36;
+const SHA256_HEX = /^[0-9a-f]{64}$/u;
+const LENGTHS = /* @__PURE__ */ new Set([UUID_LENGTH, 64]);
+const unique = (values) => [...new Set(values)].sort();
+const candidatesOf = (strings) => {
+	const all = [...strings];
+	return {
+		minBundleIds: unique(all.filter(isUUIDv7)),
+		fingerprints: unique(all.filter((value) => SHA256_HEX.test(value)))
+	};
+};
+const literalOf = (value, what) => {
+	if (value === null || value === void 0) return null;
+	if (value.type === "string") return value.value;
+	if (value.type === "int") return String(value.value);
+	return { unreadable: value.type === "reference" ? `${what} is a resource reference (${value.name ?? `@0x${value.id.toString(16)}`}), not a literal` : `${what} is not a string` };
+};
+/**
+* The channel an Android app reports from its `com.hotupdater.CHANNEL`
+* meta-data, as the SDK reads it (`NativeConfigUtils`): the value as a
+* string, and none when it is empty, which the SDK reports as `production`.
+*/
+const androidChannelOf = (value) => {
+	if (value === void 0) return null;
+	if (value.type === "boolean") return String(value.value);
+	const channel = literalOf(value, "The com.hotupdater.CHANNEL meta-data");
+	return channel === "" ? null : channel;
+};
+const readAndroid = async (source, kind, entries, budget) => {
+	const manifestEntry = findZipEntry(entries, kind === "aab" ? "base/manifest/AndroidManifest.xml" : "AndroidManifest.xml");
+	if (manifestEntry === void 0) throw new NativeArtifactError("UNREADABLE", `The ${kind === "aab" ? ".aab has no base/manifest/AndroidManifest.xml" : ".apk has no AndroidManifest.xml"}.`);
+	const manifestBytes = await readZipEntry(source, manifestEntry, METADATA_BYTES, budget);
+	const manifest = readAndroidManifest(kind === "aab" ? parseProtoManifest(manifestBytes) : parseBinaryManifest(manifestBytes));
+	const strings = [];
+	const dexes = filterZipEntries(entries, (name) => kind === "aab" ? /^base\/dex\/classes\d*\.dex$/u.test(name) : /^classes\d*\.dex$/u.test(name));
+	for (const entry of dexes) strings.push(...readDexStrings(await readZipEntry(source, entry, DEX_BYTES, budget), LENGTHS));
+	const { minBundleIds, fingerprints } = candidatesOf(strings);
+	const bundle = findZipEntry(entries, builtInBundlePathOf(kind));
+	return {
+		platform: "android",
+		kind,
+		appId: manifest.packageName,
+		appVersion: literalOf(manifest.versionName, "versionName"),
+		buildNumber: manifest.versionCode === null ? null : String(manifest.versionCode),
+		channel: androidChannelOf(manifest.metaData.get("com.hotupdater.CHANNEL")),
+		minBundleIdCandidates: minBundleIds,
+		fingerprintCandidates: fingerprints,
+		builtInBundle: bundle === void 0 ? null : {
+			path: bundle.name,
+			byteSize: bundle.uncompressedSize
+		}
+	};
+};
+const stringValue = (value) => typeof value === "string" && value !== "" ? value : null;
+const readIos = async (source, kind, entries, budget) => {
+	const infoPlist = kind === "ipa" ? /^Payload\/[^/]+\.app\/Info\.plist$/u : /^[^/]+\.app\/Info\.plist$/u;
+	const plistEntry = findZipEntry(entries, (name) => infoPlist.test(name));
+	if (plistEntry === void 0) throw new NativeArtifactError("UNREADABLE", kind === "ipa" ? "The .ipa has no Payload/<App>.app/Info.plist." : "The .app.zip has no <App>.app/Info.plist at its root.");
+	const appDirectory = plistEntry.name.slice(0, -10);
+	const plist = parsePlist(await readZipEntry(source, plistEntry, METADATA_BYTES, budget));
+	if (plist === null || typeof plist !== "object" || Array.isArray(plist)) throw new NativeArtifactError("UNREADABLE", "The app's Info.plist is not a dictionary.");
+	const info = plist;
+	const machO = (entry) => readMachOStrings((start, end) => readZipEntryRange(source, entry, start, end, budget), LENGTHS);
+	const frameworks = filterZipEntries(entries, (name) => {
+		const match = new RegExp(`^${appDirectory.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}Frameworks/([^/]+)\\.framework/([^/]+)$`, "u").exec(name);
+		return match !== null && match[1] === match[2];
+	});
+	const sdk = frameworks.find(({ name }) => name.endsWith("/HotUpdater"));
+	const executable = stringValue(info["CFBundleExecutable"]);
+	const executableEntry = executable === null ? void 0 : findZipEntry(entries, `${appDirectory}${executable}`);
+	let strings = sdk === void 0 ? [] : await machO(sdk);
+	if (!strings.some(isUUIDv7) && executableEntry !== void 0) strings = await machO(executableEntry);
+	if (!strings.some(isUUIDv7)) {
+		for (const framework of frameworks) if (framework !== sdk) strings.push(...await machO(framework));
+	}
+	const { minBundleIds, fingerprints } = candidatesOf(strings);
+	const bundle = findZipEntry(entries, builtInBundlePathOf(kind, appDirectory));
+	const channel = info["HOT_UPDATER_CHANNEL"];
+	return {
+		platform: "ios",
+		kind,
+		appId: stringValue(info["CFBundleIdentifier"]),
+		appVersion: stringValue(info["CFBundleShortVersionString"]),
+		buildNumber: stringValue(info["CFBundleVersion"]),
+		channel: channel === void 0 || channel === "" ? null : typeof channel === "string" ? channel : { unreadable: "HOT_UPDATER_CHANNEL is not a string" },
+		minBundleIdCandidates: minBundleIds,
+		fingerprintCandidates: fingerprints,
+		builtInBundle: bundle === void 0 ? null : {
+			path: bundle.name,
+			byteSize: bundle.uncompressedSize
+		}
+	};
+};
+/**
+* Reads a store artifact (`.ipa`, `.aab` or `.apk`) by its file name's
+* extension: what its app reports at runtime, and its built-in bundle. It
+* reads the archive's directory, the manifest or Info.plist, and the app's
+* code, but not the built-in bundle, so a large artifact is never held
+* whole. Whether the result can be imported is `checkNativeArtifact`'s.
+*/
+const readNativeArtifact = async (source, fileName, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}) => {
+	const kind = nativeArtifactKindOf(fileName);
+	if (kind === null) throw new NativeArtifactError("UNSUPPORTED_FILE", `${fileName} is not an .ipa, .aab, .apk or a simulator .app. Import the artifact of a release build.`);
+	const budget = {
+		remaining: READ_BUDGET_BYTES,
+		deadline: Date.now() + timeoutMs
+	};
+	const timed = {
+		size: source.size,
+		read(offset, length) {
+			if (Date.now() > budget.deadline) return Promise.reject(new NativeArtifactError("UNREADABLE", "Reading the artifact took too long."));
+			return source.read(offset, length);
+		}
+	};
+	try {
+		const entries = await readZipDirectory(timed);
+		return await (kind === "ipa" || kind === "app" ? readIos(timed, kind, entries, budget) : readAndroid(timed, kind, entries, budget));
+	} catch (error) {
+		if (error instanceof NativeArtifactError) throw error;
+		throw new NativeArtifactError("UNREADABLE", `The artifact is malformed: ${error instanceof Error ? error.message : String(error)}.`);
+	}
+};
+//#endregion
+//#region src/nativeArtifact/checkNativeArtifact.ts
+/** The channel an app without a default channel reports. */
+const DEFAULT_CHANNEL = "production";
+const isUnreadable = (value) => typeof value === "object" && value !== null && "unreadable" in value;
+/**
+* Whether a read artifact can be imported as a native build, whose built-in
+* bundle OTAs patch from, and what it registers as. It refuses an artifact
+* that ships no built-in bundle, such as a debug build, which loads its
+* JavaScript from Metro, one built without the native SDK's build step (no MIN_BUNDLE_ID), and
+* one the project's update strategy can't place: no fingerprint under the
+* fingerprint strategy, or no app version a device compares under the
+* appVersion strategy. With `appIds`, the identifiers the project's
+* `nativeBuild` schemes name, it warns about an artifact of another app.
+*/
+const checkNativeArtifact = (info, { updateStrategy, appIds = [], channel: channelOverride }) => {
+	const problems = [];
+	const warnings = [];
+	const refuse = (code, message) => problems.push({
+		code,
+		message
+	});
+	if (info.builtInBundle === null) refuse("NO_BUILT_IN_BUNDLE", `The .${info.kind} has no ${builtInBundlePathOf(info.kind)}, so it ships no built-in bundle to patch from. A debug build loads its JavaScript from Metro, and a release build packs it there unless the project renames its bundle. Import a release build.`);
+	const [minBundleId, ...otherMinBundleIds] = info.minBundleIdCandidates;
+	if (minBundleId === void 0) refuse("NO_MIN_BUNDLE_ID", "The app's code holds no MIN_BUNDLE_ID: it was built without @hot-updater/react-native, or with a version of it that doesn't compile MIN_BUNDLE_ID in. Rebuild it with the @hot-updater/react-native this project uses.");
+	else if (otherMinBundleIds.length > 0) refuse("AMBIGUOUS_MIN_BUNDLE_ID", `The app's code holds several UUIDv7 strings (${info.minBundleIdCandidates.join(", ")}), so which is MIN_BUNDLE_ID can't be told.`);
+	let fingerprintHash = null;
+	let appVersion = null;
+	if (updateStrategy === "fingerprint") {
+		const [fingerprint, ...others] = info.fingerprintCandidates;
+		if (fingerprint === void 0) refuse("NO_FINGERPRINT", "The app's code holds no fingerprint, but hot-updater.config.ts updates by fingerprint: it was built without fingerprint.json, or with a @hot-updater/react-native that doesn't compile the fingerprint in, so its app can't check for fingerprint updates.");
+		else if (others.length > 0) refuse("AMBIGUOUS_FINGERPRINT", `The app's code holds several SHA-256 strings (${info.fingerprintCandidates.join(", ")}), so which is its fingerprint can't be told.`);
+		else fingerprintHash = fingerprint;
+	} else if (info.appVersion === null) refuse("NO_APP_VERSION", `The app has no ${info.platform === "ios" ? "CFBundleShortVersionString" : "versionName"}, which the appVersion strategy updates by.`);
+	else if (isUnreadable(info.appVersion)) refuse("NO_APP_VERSION", `The app's ${info.appVersion.unreadable}.`);
+	else if (canonicalizeAppVersion(info.appVersion) === null) refuse("INVALID_SCOPE", `The app version ${info.appVersion} holds no version a device compares, such as 1.4.0, so no appVersion update targets it.`);
+	else appVersion = info.appVersion;
+	let channel = DEFAULT_CHANNEL;
+	if (channelOverride !== void 0) {
+		channel = channelOverride;
+		try {
+			encodeChannelKey(channel);
+		} catch (error) {
+			refuse("INVALID_SCOPE", `The channel ${JSON.stringify(channel)} is no channel a release can target: ${error instanceof Error ? error.message : String(error)}.`);
+		}
+	} else if (isUnreadable(info.channel)) refuse("INVALID_SCOPE", `${info.channel.unreadable}, so the channel its app reports can't be read: name it with --channel.`);
+	else if (info.channel !== null) {
+		channel = info.channel;
+		try {
+			encodeChannelKey(channel);
+		} catch (error) {
+			refuse("INVALID_SCOPE", `The app's channel ${JSON.stringify(channel)} is no channel a release can target: ${error instanceof Error ? error.message : String(error)}.`);
+		}
+	}
+	if (appIds.length > 0 && info.appId !== null && !appIds.includes(info.appId)) warnings.push({
+		code: "APP_ID_MISMATCH",
+		message: `The app is ${info.appId}, which no ${info.platform} scheme in nativeBuild names (${appIds.join(", ")}): check that it is this project's build.`
+	});
+	if (problems.length > 0 || minBundleId === void 0) return {
+		ok: false,
+		problems,
+		warnings
+	};
+	return {
+		ok: true,
+		warnings,
+		build: {
+			platform: info.platform,
+			kind: info.kind,
+			appId: info.appId,
+			buildNumber: info.buildNumber,
+			minBundleId,
+			channel,
+			fingerprintHash,
+			appVersion,
+			builtInBundlePath: info.builtInBundle.path
+		}
+	};
+};
+/**
+* The refusal of an artifact whose built-in bundle is already registered:
+* the registry takes a MIN_BUNDLE_ID once.
+*/
+const alreadyImportedProblem = (minBundleId, nativeBuildId) => ({
+	code: "ALREADY_IMPORTED",
+	...nativeBuildId === null ? {} : { nativeBuildId },
+	message: nativeBuildId === null ? `The built-in bundle ${minBundleId} is already registered, as a bundle that is no native build's.` : `This build is already registered as native build ${nativeBuildId} (built-in bundle ${minBundleId}).`
+});
+//#endregion
+export { NativeArtifactError, alreadyImportedProblem, blobSource, checkNativeArtifact, findZipEntry, openZipEntry, readNativeArtifact, readZipDirectory };