@oh-my-pi/pi-utils 17.4.0 → 17.4.2

package/src/ar/reader.ts

@@ -0,0 +1,162 @@
+import { ensureParentDirectories, resolveArchiveLinkPath, upsertArchiveEntry } from "./entries";
+import { ArchiveError } from "./error";
+import { type ArchiveLimits, assertArchiveMemberSize, DEFAULT_ARCHIVE_LIMITS } from "./limits";
+import { formatArchivePathForError, normalizeArchiveLookupPath } from "./paths";
+import type {
+	ArchiveDirectoryEntry,
+	ArchiveFormat,
+	ArchiveIndexEntry,
+	ArchiveNode,
+	ExtractedArchiveFile,
+} from "./types";
+
+/** Raise the canonical error for a symlink whose target cannot be materialized. */
+export function throwUnreadableArchiveLink(targetPath: string, memberPath: string): never {
+	throw new ArchiveError(
+		`Archive symlink '${formatArchivePathForError(memberPath)}' cannot be materialized from target '${formatArchivePathForError(targetPath)}'`,
+	);
+}
+
+/**
+ * An indexed, read-only view over a single archive. Member payloads stay
+ * lazy behind their format's `MemberSource`; symlink aliases are traversed
+ * lazily so N files behind M directory aliases never inflate the index to
+ * N×M entries during listing.
+ */
+export class ArchiveReader {
+	readonly format: ArchiveFormat;
+	readonly limits: ArchiveLimits;
+	#entries = new Map<string, ArchiveIndexEntry>();
+
+	constructor(format: ArchiveFormat, entries: ArchiveIndexEntry[], limits: ArchiveLimits = DEFAULT_ARCHIVE_LIMITS) {
+		this.format = format;
+		this.limits = limits;
+		for (const entry of entries) {
+			upsertArchiveEntry(this.#entries, entry);
+		}
+		ensureParentDirectories(this.#entries, limits);
+	}
+
+	/**
+	 * Raw index entries, including link records and synthesized directories.
+	 * For extraction/merge flows that need storage kinds; path lookups should
+	 * use {@link getNode}/{@link readFile}, which resolve symlink aliases.
+	 */
+	indexEntries(): IterableIterator<ArchiveIndexEntry> {
+		return this.#entries.values();
+	}
+
+	/** Resolve a path to its node, or `undefined` when absent or escaping the root. */
+	getNode(subPath?: string): ArchiveNode | undefined {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (normalizedPath === undefined) return undefined;
+		if (normalizedPath === "") {
+			return { path: "", isDirectory: true, size: 0 };
+		}
+
+		const resolvedPath = resolveArchiveLinkPath(this.#entries, normalizedPath, this.limits.maxLinkDepth);
+		if (resolvedPath === "") {
+			return { path: normalizedPath, isDirectory: true, size: 0 };
+		}
+		const entry = this.#entries.get(resolvedPath);
+		if (!entry) return undefined;
+		return {
+			path: normalizedPath,
+			isDirectory: entry.isDirectory,
+			size: entry.size,
+			mtimeMs: entry.mtimeMs,
+			mode: entry.mode,
+		};
+	}
+
+	/** List one directory's children, sorted case-insensitively by name. */
+	listDirectory(subPath?: string): ArchiveDirectoryEntry[] {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (normalizedPath === undefined) {
+			throw new ArchiveError("Archive path cannot contain '..'");
+		}
+
+		const resolvedPath = normalizedPath
+			? resolveArchiveLinkPath(this.#entries, normalizedPath, this.limits.maxLinkDepth)
+			: "";
+		if (normalizedPath && resolvedPath !== "") {
+			const entry = this.#entries.get(resolvedPath);
+			if (!entry) {
+				throw new ArchiveError(`Archive path '${normalizedPath}' not found`);
+			}
+			if (!entry.isDirectory) {
+				throw new ArchiveError(`Archive path '${normalizedPath}' is not a directory`);
+			}
+		}
+
+		const sourcePrefix = resolvedPath ? `${resolvedPath}/` : "";
+		const children = new Map<string, ArchiveDirectoryEntry>();
+
+		for (const entry of this.#entries.values()) {
+			if (resolvedPath) {
+				if (!entry.path.startsWith(sourcePrefix) || entry.path === resolvedPath) continue;
+			}
+
+			const relativePath = resolvedPath ? entry.path.slice(sourcePrefix.length) : entry.path;
+			const nextSegment = relativePath.split("/")[0];
+			if (!nextSegment) continue;
+
+			const childPath = normalizedPath ? `${normalizedPath}/${nextSegment}` : nextSegment;
+			if (children.has(childPath)) continue;
+
+			const sourceChildPath = resolvedPath ? `${resolvedPath}/${nextSegment}` : nextSegment;
+			const resolvedChildPath = resolveArchiveLinkPath(this.#entries, sourceChildPath, this.limits.maxLinkDepth);
+			const childEntry = resolvedChildPath ? this.#entries.get(resolvedChildPath) : undefined;
+			const isDirectory = resolvedChildPath === "" || childEntry?.isDirectory === true || relativePath.includes("/");
+			children.set(childPath, {
+				name: nextSegment,
+				path: childPath,
+				isDirectory,
+				size: isDirectory ? 0 : (childEntry?.size ?? entry.size),
+				mtimeMs: childEntry?.mtimeMs ?? entry.mtimeMs,
+				mode: childEntry?.mode ?? entry.mode,
+			});
+		}
+
+		return [...children.values()].sort((left, right) =>
+			left.name.toLowerCase().localeCompare(right.name.toLowerCase()),
+		);
+	}
+
+	/** Extract one file member's bytes, following symlink aliases. */
+	async readFile(subPath: string): Promise<ExtractedArchiveFile> {
+		const normalizedPath = normalizeArchiveLookupPath(subPath);
+		if (!normalizedPath) {
+			throw new ArchiveError("Archive file path is required");
+		}
+
+		const resolvedPath = resolveArchiveLinkPath(this.#entries, normalizedPath, this.limits.maxLinkDepth);
+		if (resolvedPath === "") {
+			throw new ArchiveError(`Archive path '${normalizedPath}' is a directory`);
+		}
+		const entry = this.#entries.get(resolvedPath);
+		if (!entry) {
+			throw new ArchiveError(`Archive file '${normalizedPath}' not found`);
+		}
+		if (entry.isDirectory) {
+			throw new ArchiveError(`Archive path '${normalizedPath}' is a directory`);
+		}
+		if (!entry.storage) {
+			throw new ArchiveError(`Archive file '${normalizedPath}' has no readable storage`);
+		}
+		assertArchiveMemberSize(entry.size, normalizedPath, this.limits);
+
+		if (entry.storage.type === "link") {
+			throwUnreadableArchiveLink(entry.storage.targetPath, normalizedPath);
+		}
+		const bytes = await entry.storage.source.read(entry.size, normalizedPath);
+		return {
+			path: normalizedPath,
+			isDirectory: false,
+			size: entry.size,
+			mtimeMs: entry.mtimeMs,
+			mode: entry.mode,
+			bytes,
+		};
+	}
+}

package/src/ar/registry.ts

@@ -0,0 +1,208 @@
+import * as path from "node:path";
+import { readArj, sniffArj } from "./arj";
+import { readAsar, sniffAsar } from "./asar";
+import { readUInt32LE } from "./bytes";
+import { readCab, sniffCab } from "./cab";
+import { bzip2Decompress, isBzip2 } from "./codecs/bzip2";
+import { gzipDecompress, isGzip } from "./codecs/gzip";
+import { lzmaAloneDecompress } from "./codecs/lzma";
+import { isCompressZ, lzwDecompress } from "./codecs/lzw";
+import { isXz, xzDecompress } from "./codecs/xz";
+import { isZstd, zstdDecompress } from "./codecs/zstd";
+import { readCpio, sniffCpio } from "./cpio";
+import { readDeb, sniffDeb } from "./deb";
+import { readIso, sniffIso } from "./iso";
+import { assertInMemorySize } from "./limits";
+import { readLzh, sniffLzh } from "./lzh";
+import { readRar, sniffRar } from "./rar";
+import { readRpm, sniffRpm } from "./rpm";
+import { readSevenZip, sniffSevenZip } from "./sevenzip";
+import { readAllBytes } from "./source";
+import { readTar, readTarEntriesFromBuffer, sniffTar } from "./tar";
+import type { ArchiveFormat, ArchiveIndexEntry, FormatReader, MemberSource } from "./types";
+import { readUnixAr, sniffUnixAr } from "./unix-ar";
+import { readZip, sniffZip } from "./zip";
+
+/**
+ * Extensions recognized per format, lowercase, without the leading dot.
+ * ZIP aliases cover the ZIP-container package families (JVM, Android, Python
+ * wheels, browser/IDE extensions, NuGet, comics); `cbr` is RAR-under-alias.
+ */
+const FORMAT_EXTENSIONS: Record<ArchiveFormat, readonly string[]> = {
+	zip: ["zip", "jar", "war", "ear", "apk", "whl", "ipa", "xpi", "vsix", "nupkg", "cbz"],
+	tar: ["tar"],
+	"tar.gz": ["tar.gz", "tgz"],
+	"tar.bz2": ["tar.bz2", "tbz2", "tbz"],
+	"tar.xz": ["tar.xz", "txz"],
+	"tar.zst": ["tar.zst", "tzst"],
+	"tar.Z": ["tar.z"],
+	asar: ["asar"],
+	rar: ["rar", "cbr"],
+	"7z": ["7z"],
+	iso: ["iso"],
+	cab: ["cab"],
+	cpio: ["cpio"],
+	rpm: ["rpm"],
+	ar: ["ar", "a", "lib"],
+	deb: ["deb"],
+	lzh: ["lzh", "lha"],
+	arj: ["arj"],
+	gz: ["gz"],
+	bz2: ["bz2"],
+	xz: ["xz"],
+	zst: ["zst"],
+	Z: ["z"],
+	lzma: ["lzma"],
+};
+
+/** Every recognized extension paired with its format, longest first. */
+const EXTENSION_TABLE: readonly (readonly [string, ArchiveFormat])[] = Object.entries(FORMAT_EXTENSIONS)
+	.flatMap(([format, extensions]) => extensions.map(ext => [ext, format as ArchiveFormat] as const))
+	.sort((left, right) => right[0].length - left[0].length);
+
+/**
+ * Regex alternation of every recognized archive extension, longest first so
+ * `.tar.gz` wins over `.gz`. Shared with `parseArchivePathCandidates` as its
+ * split pattern so extension recognition and path splitting never drift.
+ */
+export const ARCHIVE_EXTENSION_ALTERNATION = EXTENSION_TABLE.map(([ext]) => ext.replace(/\./g, "\\.")).join("|");
+
+/** Infer an archive format from a filesystem path's extension. */
+export function archiveFormatFromPath(filePath: string): ArchiveFormat | undefined {
+	const normalized = filePath.toLowerCase();
+	for (const [ext, format] of EXTENSION_TABLE) {
+		if (normalized.endsWith(`.${ext}`)) return format;
+	}
+	return undefined;
+}
+
+/** Strip the recognized archive extension for single-member pseudo-archives. */
+function stemMemberName(archivePath: string | undefined): string {
+	if (!archivePath) return "data";
+	const base = path.basename(archivePath.replace(/\\/g, "/"));
+	const lower = base.toLowerCase();
+	for (const [ext] of EXTENSION_TABLE) {
+		if (lower.length > ext.length + 1 && lower.endsWith(`.${ext}`)) {
+			return base.slice(0, base.length - ext.length - 1);
+		}
+	}
+	return base || "data";
+}
+
+/** In-memory bytes as a `MemberSource` (single-member pseudo-archives). */
+class BufferMember implements MemberSource {
+	#bytes: Uint8Array;
+	constructor(bytes: Uint8Array) {
+		this.#bytes = bytes;
+	}
+	async read(): Promise<Uint8Array> {
+		return this.#bytes;
+	}
+}
+
+/**
+ * Reader for one compressed stream: decompress bounded, then index the inner
+ * bytes as tar when they are one, else surface a single stem-named member.
+ * Serves both `tar.<codec>` and bare `.<codec>` formats, so `foo.tgz` holding
+ * a tar lists as a tree while `notes.txt.gz` lists as `notes.txt`.
+ */
+function compressedReader(decompress: (bytes: Uint8Array, maxOutput: number) => Promise<Uint8Array>): FormatReader {
+	return async (source, options) => {
+		assertInMemorySize(source.size, options.limits);
+		const inner = await decompress(await readAllBytes(source), options.limits.maxInMemorySize);
+		assertInMemorySize(inner.byteLength, options.limits);
+		if (sniffTar(inner)) {
+			return readTarEntriesFromBuffer(inner, options);
+		}
+		const entry: ArchiveIndexEntry = {
+			path: stemMemberName(options.archivePath),
+			isDirectory: false,
+			size: inner.byteLength,
+			storage: { type: "member", source: new BufferMember(inner) },
+		};
+		return [entry];
+	};
+}
+
+const READERS: Record<ArchiveFormat, FormatReader> = {
+	zip: readZip,
+	tar: readTar,
+	"tar.gz": compressedReader(gzipDecompress),
+	"tar.bz2": compressedReader(bzip2Decompress),
+	"tar.xz": compressedReader(xzDecompress),
+	"tar.zst": compressedReader(zstdDecompress),
+	"tar.Z": compressedReader(lzwDecompress),
+	asar: readAsar,
+	rar: readRar,
+	"7z": readSevenZip,
+	iso: readIso,
+	cab: readCab,
+	cpio: readCpio,
+	rpm: readRpm,
+	ar: readUnixAr,
+	deb: readDeb,
+	lzh: readLzh,
+	arj: readArj,
+	gz: compressedReader(gzipDecompress),
+	bz2: compressedReader(bzip2Decompress),
+	xz: compressedReader(xzDecompress),
+	zst: compressedReader(zstdDecompress),
+	Z: compressedReader(lzwDecompress),
+	lzma: compressedReader(lzmaAloneDecompress),
+};
+
+/** The format reader responsible for `format`. */
+export function formatReaderFor(format: ArchiveFormat): FormatReader {
+	return READERS[format];
+}
+
+/**
+ * Content-sniff order. Magic-at-zero formats first, then structural probes,
+ * then compression wrappers (reported as their `tar.*` variant — the reader
+ * falls back to a single member when the inner stream is not tar), then
+ * offset magics (tar at 257, ISO at 32769), and last the bounded ZIP-EOCD
+ * tail scan for zips with prepended data.
+ */
+const SNIFFERS: readonly (readonly [ArchiveFormat, (bytes: Uint8Array) => boolean])[] = [
+	["zip", sniffZip],
+	["rar", sniffRar],
+	["7z", sniffSevenZip],
+	["cab", sniffCab],
+	["rpm", sniffRpm],
+	["arj", sniffArj],
+	["lzh", sniffLzh],
+	["cpio", sniffCpio],
+	["deb", sniffDeb],
+	["ar", sniffUnixAr],
+	["asar", sniffAsar],
+	["tar.gz", isGzip],
+	["tar.bz2", isBzip2],
+	["tar.xz", isXz],
+	["tar.zst", isZstd],
+	["tar.Z", isCompressZ],
+	["iso", sniffIso],
+	["tar", sniffTar],
+];
+
+const ZIP_EOCD_SIGNATURE = 0x06054b50;
+const ZIP_EOCD_MIN_LENGTH = 22;
+const ZIP_EOCD_MAX_COMMENT_LENGTH = 0xffff;
+
+/**
+ * Sniff an archive format from its bytes. Pass the full buffer when
+ * available: most probes read the head, but tar needs offset 257, ISO offset
+ * 32769, and the trailing ZIP central-directory scan needs the tail.
+ */
+export function sniffArchiveFormat(bytes: Uint8Array): ArchiveFormat | undefined {
+	for (const [format, sniff] of SNIFFERS) {
+		if (sniff(bytes)) return format;
+	}
+	// ZIP with prepended data (self-extractors, some installers): bounded
+	// backward scan for the end-of-central-directory record.
+	const scanStart = bytes.byteLength - ZIP_EOCD_MIN_LENGTH;
+	const scanLimit = Math.max(0, bytes.byteLength - ZIP_EOCD_MIN_LENGTH - ZIP_EOCD_MAX_COMMENT_LENGTH);
+	for (let offset = scanStart; offset >= scanLimit; offset--) {
+		if (readUInt32LE(bytes, offset) === ZIP_EOCD_SIGNATURE) return "zip";
+	}
+	return undefined;
+}

package/src/ar/rpm.ts

@@ -0,0 +1,320 @@
+import { readUInt32BE } from "./bytes";
+import { bzip2Decompress, isBzip2 } from "./codecs/bzip2";
+import { gzipDecompress, isGzip } from "./codecs/gzip";
+import { lzmaAloneDecompress } from "./codecs/lzma";
+import { isXz, xzDecompress } from "./codecs/xz";
+import { isZstd, zstdDecompress } from "./codecs/zstd";
+import { readCpioEntriesFromBuffer, sniffCpio } from "./cpio";
+import { ArchiveError } from "./error";
+import { assertEntryCount, assertIndexSize, assertInMemorySize } from "./limits";
+import type { ByteSource } from "./source";
+import type { ArchiveIndexEntry, FormatReader, FormatReadOptions } from "./types";
+
+const RPM_LEAD_SIZE = 96;
+const RPM_HEADER_INTRO_SIZE = 16;
+const RPM_INDEX_ENTRY_SIZE = 16;
+const RPM_HEADER_MAGIC = 0x8eade801;
+const RPM_SIGNATURE_TYPE_HEADER = 5;
+const RPM_TAG_NAME = 1000;
+const RPM_TAG_VERSION = 1001;
+const RPM_TAG_PAYLOAD_FORMAT = 1124;
+const RPM_TAG_PAYLOAD_COMPRESSOR = 1125;
+const RPM_TAG_PAYLOAD_FLAGS = 1126;
+const RPM_TYPE_STRING = 6;
+const UTF8_FATAL_DECODER = new TextDecoder("utf-8", { fatal: true });
+
+interface HeaderIntro {
+	indexCount: number;
+	dataSize: number;
+	bodySize: number;
+	totalSize: number;
+}
+
+interface RpmMetadata {
+	name?: string;
+	version?: string;
+	payloadFormat?: string;
+	payloadCompressor?: string;
+	payloadFlags?: string;
+}
+
+function align(value: number, alignment: number): number {
+	const remainder = value % alignment;
+	return remainder === 0 ? value : value + alignment - remainder;
+}
+
+async function readExact(source: ByteSource, start: number, end: number, what: string): Promise<Uint8Array> {
+	if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > source.size) {
+		throw new ArchiveError(`Invalid RPM package: truncated ${what}`);
+	}
+	const bytes = await source.read(start, end);
+	if (bytes.byteLength !== end - start) throw new ArchiveError(`Invalid RPM package: truncated ${what}`);
+	return bytes;
+}
+
+function parseHeaderIntro(bytes: Uint8Array, options: FormatReadOptions, what: string): HeaderIntro {
+	if (bytes.byteLength !== RPM_HEADER_INTRO_SIZE || readUInt32BE(bytes, 0) !== RPM_HEADER_MAGIC) {
+		throw new ArchiveError(`Invalid RPM package: corrupt ${what} header magic`);
+	}
+	for (let offset = 4; offset < 8; offset++) {
+		if (bytes[offset] !== 0) throw new ArchiveError(`Invalid RPM package: corrupt ${what} header reserved bytes`);
+	}
+	const indexCount = readUInt32BE(bytes, 8);
+	const dataSize = readUInt32BE(bytes, 12);
+	assertEntryCount(indexCount, options.limits);
+	const indexSize = indexCount * RPM_INDEX_ENTRY_SIZE;
+	const bodySize = indexSize + dataSize;
+	if (!Number.isSafeInteger(bodySize)) throw new ArchiveError(`Invalid RPM package: ${what} header is too large`);
+	assertIndexSize(RPM_HEADER_INTRO_SIZE + bodySize, options.limits, `RPM ${what} header`);
+	return { indexCount, dataSize, bodySize, totalSize: RPM_HEADER_INTRO_SIZE + bodySize };
+}
+
+function validateHeaderBody(body: Uint8Array, intro: HeaderIntro, what: string): void {
+	const indexSize = intro.indexCount * RPM_INDEX_ENTRY_SIZE;
+	if (body.byteLength !== intro.bodySize) throw new ArchiveError(`Invalid RPM package: truncated ${what} header`);
+	for (let index = 0; index < intro.indexCount; index++) {
+		const recordOffset = index * RPM_INDEX_ENTRY_SIZE;
+		const tag = readUInt32BE(body, recordOffset);
+		const type = readUInt32BE(body, recordOffset + 4);
+		const offset = readUInt32BE(body, recordOffset + 8);
+		const count = readUInt32BE(body, recordOffset + 12);
+		if (offset > intro.dataSize) throw new ArchiveError(`Invalid RPM package: tag ${tag} points outside header data`);
+		const remaining = intro.dataSize - offset;
+		let elementSize = 0;
+		if (type === 1 || type === 2 || type === 7) elementSize = 1;
+		else if (type === 3) elementSize = 2;
+		else if (type === 4) elementSize = 4;
+		else if (type === 5) elementSize = 8;
+		else if (type === 0) {
+			if (count !== 0) throw new ArchiveError(`Invalid RPM package: null tag ${tag} has values`);
+			continue;
+		} else if (type === RPM_TYPE_STRING || type === 8 || type === 9) {
+			const stringCount = type === RPM_TYPE_STRING ? 1 : count;
+			if (type === RPM_TYPE_STRING && count !== 1) {
+				throw new ArchiveError(`Invalid RPM package: string tag ${tag} has an invalid count`);
+			}
+			if (stringCount > remaining) {
+				throw new ArchiveError(`Invalid RPM package: string tag ${tag} exceeds header data`);
+			}
+			let cursor = indexSize + offset;
+			const limit = indexSize + intro.dataSize;
+			for (let stringIndex = 0; stringIndex < stringCount; stringIndex++) {
+				while (cursor < limit && body[cursor] !== 0) cursor++;
+				if (cursor === limit) {
+					throw new ArchiveError(`Invalid RPM package: string tag ${tag} is not NUL-terminated`);
+				}
+				cursor++;
+			}
+			continue;
+		} else {
+			throw new ArchiveError(`Invalid RPM package: tag ${tag} uses unknown data type ${type}`);
+		}
+		if (offset % elementSize !== 0) throw new ArchiveError(`Invalid RPM package: tag ${tag} data is misaligned`);
+		if (count * elementSize > remaining)
+			throw new ArchiveError(`Invalid RPM package: tag ${tag} exceeds header data`);
+	}
+}
+
+function readHeaderString(
+	body: Uint8Array,
+	indexSize: number,
+	dataSize: number,
+	offset: number,
+	count: number,
+	type: number,
+	tag: number,
+): string {
+	if (type !== RPM_TYPE_STRING || count !== 1) {
+		throw new ArchiveError(`Invalid RPM package: tag ${tag} must contain one string`);
+	}
+	const start = indexSize + offset;
+	const limit = indexSize + dataSize;
+	let end = start;
+	while (end < limit && body[end] !== 0) end++;
+	if (end === limit) throw new ArchiveError(`Invalid RPM package: tag ${tag} string is not NUL-terminated`);
+	if (end - start > 4096) throw new ArchiveError(`Invalid RPM package: tag ${tag} string is too large`);
+	try {
+		return UTF8_FATAL_DECODER.decode(body.subarray(start, end));
+	} catch {
+		throw new ArchiveError(`Invalid RPM package: tag ${tag} is not valid UTF-8`);
+	}
+}
+
+function parseMainHeader(body: Uint8Array, intro: HeaderIntro): RpmMetadata {
+	validateHeaderBody(body, intro, "main");
+	const indexSize = intro.indexCount * RPM_INDEX_ENTRY_SIZE;
+	if (body.byteLength !== intro.bodySize) throw new ArchiveError("Invalid RPM package: truncated main header");
+	const metadata: RpmMetadata = {};
+	for (let index = 0; index < intro.indexCount; index++) {
+		const recordOffset = index * RPM_INDEX_ENTRY_SIZE;
+		const tag = readUInt32BE(body, recordOffset);
+		const type = readUInt32BE(body, recordOffset + 4);
+		const offset = readUInt32BE(body, recordOffset + 8);
+		const count = readUInt32BE(body, recordOffset + 12);
+		if (offset > intro.dataSize) throw new ArchiveError(`Invalid RPM package: tag ${tag} points outside header data`);
+		if (
+			tag !== RPM_TAG_NAME &&
+			tag !== RPM_TAG_VERSION &&
+			tag !== RPM_TAG_PAYLOAD_FORMAT &&
+			tag !== RPM_TAG_PAYLOAD_COMPRESSOR &&
+			tag !== RPM_TAG_PAYLOAD_FLAGS
+		) {
+			continue;
+		}
+		const value = readHeaderString(body, indexSize, intro.dataSize, offset, count, type, tag);
+		switch (tag) {
+			case RPM_TAG_NAME:
+				metadata.name = value;
+				break;
+			case RPM_TAG_VERSION:
+				metadata.version = value;
+				break;
+			case RPM_TAG_PAYLOAD_FORMAT:
+				metadata.payloadFormat = value;
+				break;
+			case RPM_TAG_PAYLOAD_COMPRESSOR:
+				metadata.payloadCompressor = value;
+				break;
+			case RPM_TAG_PAYLOAD_FLAGS:
+				metadata.payloadFlags = value;
+				break;
+		}
+	}
+	return metadata;
+}
+
+function rpmIdentity(metadata: RpmMetadata, leadName: string): string {
+	if (metadata.name && metadata.version) return `${metadata.name}-${metadata.version}`;
+	return metadata.name ?? leadName;
+}
+
+function sniffLzmaAlone(bytes: Uint8Array): boolean {
+	if (bytes.byteLength < 13 || bytes[0]! > 224) return false;
+	const dictionarySize = (bytes[1]! | (bytes[2]! << 8) | (bytes[3]! << 16) | (bytes[4]! << 24)) >>> 0;
+	if (dictionarySize < 4096) return false;
+	const rounded = 2 ** Math.ceil(Math.log2(dictionarySize));
+	return dictionarySize === rounded || dictionarySize === rounded - rounded / 4;
+}
+
+async function decompressPayload(
+	payload: Uint8Array,
+	metadata: RpmMetadata,
+	identity: string,
+	maxOutput: number,
+): Promise<Uint8Array> {
+	const compressor = metadata.payloadCompressor?.trim().toLowerCase();
+	let method = compressor;
+	if (!method || !["gzip", "gz", "bzip2", "bzip", "xz", "lzma", "zstd", "zstdio", "none"].includes(method)) {
+		if (isGzip(payload)) method = "gzip";
+		else if (isBzip2(payload)) method = "bzip2";
+		else if (isXz(payload)) method = "xz";
+		else if (isZstd(payload)) method = "zstd";
+		else if (sniffLzmaAlone(payload)) method = "lzma";
+		else if (sniffCpio(payload)) method = "none";
+		else {
+			throw new ArchiveError(
+				`RPM package '${identity}' uses unsupported payload compressor '${metadata.payloadCompressor ?? "unknown"}'`,
+			);
+		}
+	}
+
+	switch (method) {
+		case "gzip":
+		case "gz":
+			return gzipDecompress(payload, maxOutput);
+		case "bzip2":
+		case "bzip":
+			return bzip2Decompress(payload, maxOutput);
+		case "xz":
+			return xzDecompress(payload, maxOutput);
+		case "zstd":
+		case "zstdio":
+			return zstdDecompress(payload, maxOutput);
+		case "lzma":
+			if (!sniffLzmaAlone(payload)) throw new ArchiveError(`RPM package '${identity}' has a malformed LZMA payload`);
+			return lzmaAloneDecompress(payload, maxOutput);
+		case "none":
+			if (!sniffCpio(payload))
+				throw new ArchiveError(`RPM package '${identity}' has an invalid uncompressed CPIO payload`);
+			return payload;
+		default:
+			throw new ArchiveError(`RPM package '${identity}' uses unsupported payload compressor '${method}'`);
+	}
+}
+
+async function readRpmArchive(source: ByteSource, options: FormatReadOptions): Promise<ArchiveIndexEntry[]> {
+	const initial = await readExact(source, 0, RPM_LEAD_SIZE + RPM_HEADER_INTRO_SIZE, "lead and signature header");
+	if (!sniffRpm(initial)) throw new ArchiveError("Invalid RPM package: bad lead magic");
+	const major = initial[4]!;
+	const packageType = (initial[6]! << 8) | initial[7]!;
+	if (major < 3 || packageType > 1) throw new ArchiveError("Unsupported RPM package lead version or type");
+	const signatureType = (initial[78]! << 8) | initial[79]!;
+	if (signatureType !== RPM_SIGNATURE_TYPE_HEADER) {
+		throw new ArchiveError(`Unsupported RPM signature type ${signatureType}; only header signatures are supported`);
+	}
+	const leadNameEnd = initial.subarray(10, 76).indexOf(0);
+	const leadNameBytes = initial.subarray(10, leadNameEnd < 0 ? 76 : 10 + leadNameEnd);
+	let leadName = "unknown package";
+	try {
+		const decoded = new TextDecoder("utf-8", { fatal: true }).decode(leadNameBytes);
+		if (decoded) leadName = decoded;
+	} catch {}
+
+	const signatureIntro = parseHeaderIntro(initial.subarray(RPM_LEAD_SIZE), options, "signature");
+	const signatureEnd = RPM_LEAD_SIZE + signatureIntro.totalSize;
+	const mainHeaderOffset = align(signatureEnd, 8);
+	const signatureBodyAndPadding = await readExact(
+		source,
+		RPM_LEAD_SIZE + RPM_HEADER_INTRO_SIZE,
+		mainHeaderOffset,
+		"signature header",
+	);
+	if (signatureBodyAndPadding.byteLength < signatureIntro.bodySize) {
+		throw new ArchiveError("Invalid RPM package: truncated signature header");
+	}
+	validateHeaderBody(signatureBodyAndPadding.subarray(0, signatureIntro.bodySize), signatureIntro, "signature");
+	for (let offset = signatureIntro.bodySize; offset < signatureBodyAndPadding.byteLength; offset++) {
+		if (signatureBodyAndPadding[offset] !== 0) {
+			throw new ArchiveError("Invalid RPM package: non-zero signature alignment padding");
+		}
+	}
+
+	const mainIntroBytes = await readExact(
+		source,
+		mainHeaderOffset,
+		mainHeaderOffset + RPM_HEADER_INTRO_SIZE,
+		"main header intro",
+	);
+	const mainIntro = parseHeaderIntro(mainIntroBytes, options, "main");
+	assertIndexSize(signatureIntro.totalSize + mainIntro.totalSize, options.limits, "RPM headers");
+	const mainBodyOffset = mainHeaderOffset + RPM_HEADER_INTRO_SIZE;
+	const mainBody = await readExact(source, mainBodyOffset, mainBodyOffset + mainIntro.bodySize, "main header");
+	const metadata = parseMainHeader(mainBody, mainIntro);
+	const identity = rpmIdentity(metadata, leadName);
+	if (metadata.payloadFormat && metadata.payloadFormat.toLowerCase() !== "cpio") {
+		throw new ArchiveError(`RPM package '${identity}' uses unsupported payload format '${metadata.payloadFormat}'`);
+	}
+
+	const payloadOffset = mainHeaderOffset + mainIntro.totalSize;
+	const payloadSize = source.size - payloadOffset;
+	assertInMemorySize(payloadSize, options.limits);
+	const payload = await readExact(source, payloadOffset, source.size, "payload");
+	const cpio = await decompressPayload(payload, metadata, identity, options.limits.maxInMemorySize);
+	assertInMemorySize(cpio.byteLength, options.limits);
+	return readCpioEntriesFromBuffer(cpio, options);
+}
+
+/** Read an RPM lead, headers, compressed payload, and its contained CPIO entries. */
+export const readRpm: FormatReader = async (source, options) => {
+	try {
+		return await readRpmArchive(source, options);
+	} catch (error) {
+		if (error instanceof ArchiveError) throw error;
+		throw new ArchiveError(error instanceof Error ? error.message : String(error));
+	}
+};
+
+/** Detect the four-byte RPM package lead magic. */
+export function sniffRpm(bytes: Uint8Array): boolean {
+	return bytes.byteLength >= 4 && bytes[0] === 0xed && bytes[1] === 0xab && bytes[2] === 0xee && bytes[3] === 0xdb;
+}