@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/rpm/header.js

@@ -0,0 +1,546 @@
+import * as plugins from '../plugins.js';
+import { readExact, readUpTo } from '../readers/bytes.js';
+import { LinuxRepoError, limitExceeded, truncated } from '../shared/errors.js';
+/**
+ * RPM lead and header structures, read the way go-rpmutils v0.4.0 (Gitea
+ * 28.2.0's pin, `go.mod:85`) reads them (`header.go:75-146`,
+ * `rpmutils.go:97-136`), so that a package Gitea accepts is accepted and one
+ * Gitea refuses (or panics on) is refused:
+ * - an index entry of a fixed-size type covers `offset .. offset + size*count`;
+ *   any other type is a run of `count` NUL-terminated strings; an entry that
+ *   does not fit the data is `malformed-header`;
+ * - a later entry with the same tag replaces an earlier one;
+ * - the main header's SHA-256 (signature tag 273), else SHA-1 (269), is
+ *   checked as lowercase hex (`digest-mismatch`).
+ */
+export const RPM_LEAD_BYTES = 96;
+const LEAD_MAGIC = [0xed, 0xab, 0xee, 0xdb];
+const HEADER_MAGIC = 0x8eade801;
+const HEADER_INTRO_BYTES = 16;
+const INDEX_ENTRY_BYTES = 16;
+/** Header data types. */
+export const RPM_TYPE = {
+    null: 0,
+    char: 1,
+    int8: 2,
+    int16: 3,
+    int32: 4,
+    int64: 5,
+    string: 6,
+    bin: 7,
+    stringArray: 8,
+    i18nString: 9,
+};
+/** Element sizes of the fixed-size types (go-rpmutils `typeSizes`); every other type is string-like. */
+const TYPE_SIZES = new Map([
+    [RPM_TYPE.null, 0],
+    [RPM_TYPE.char, 1],
+    [RPM_TYPE.int8, 1],
+    [RPM_TYPE.int16, 2],
+    [RPM_TYPE.int32, 4],
+    [RPM_TYPE.int64, 8],
+    [RPM_TYPE.bin, 1],
+]);
+/** Data alignment go-rpmutils applies when it writes a header (`typeAlign`). */
+const TYPE_ALIGNMENT = new Map([
+    [RPM_TYPE.int16, 2],
+    [RPM_TYPE.int32, 4],
+    [RPM_TYPE.int64, 8],
+]);
+/** Signature header tags. */
+export const RPM_SIGNATURE_TAG = {
+    headerSignatures: 62,
+    dsa: 267,
+    rsa: 268,
+    sha1: 269,
+    longArchiveSize: 271,
+    sha256: 273,
+    size: 1000,
+    pgp: 1002,
+    md5: 1004,
+    gpg: 1005,
+    payloadSize: 1007,
+    reservedSpace: 1008,
+};
+/** Region tags below this value are dropped when a header is rewritten. */
+const RPM_TAG_HEADER_REGIONS = 64;
+/**
+ * A parsed header: its exact bytes, as read, and its index entries. The index
+ * stays in the header bytes; only the end of each entry's contents is kept
+ * beside it (4 bytes per entry), and finding the end of a string entry may
+ * build a NUL directory of about 3% of the data (`NulIndex`), so a header
+ * costs little more than its own bytes: reading a 64 MiB header peaks at
+ * about 1.33x its bytes with 4.19M entries and 1.12x with data of all NULs
+ * (Node 24.20.0). `IRpmHeaderEntry` objects are made only for the entries
+ * asked for.
+ */
+export class RpmHeader {
+    /** The header bytes as read: intro, index and data (with the padding of a signature header). */
+    bytes;
+    data;
+    /** Number of index entries. */
+    entryCount;
+    view;
+    ends;
+    lookup = new Map();
+    maxEntries;
+    constructor(bytesArg, endsArg, dataStartArg, maxEntriesArg) {
+        this.bytes = bytesArg;
+        this.data = bytesArg.subarray(dataStartArg);
+        this.entryCount = endsArg.length;
+        this.view = new DataView(bytesArg.buffer, bytesArg.byteOffset, bytesArg.byteLength);
+        this.ends = endsArg;
+        this.maxEntries = maxEntriesArg;
+    }
+    /** The tag of index entry `indexArg`. */
+    tagAt(indexArg) {
+        return this.view.getInt32(HEADER_INTRO_BYTES + indexArg * INDEX_ENTRY_BYTES);
+    }
+    /** Index entry `indexArg`. */
+    entryAt(indexArg) {
+        const at = HEADER_INTRO_BYTES + indexArg * INDEX_ENTRY_BYTES;
+        return {
+            tag: this.view.getInt32(at),
+            type: this.view.getInt32(at + 4),
+            count: this.view.getInt32(at + 12),
+            start: this.view.getInt32(at + 8),
+            end: this.ends[indexArg],
+        };
+    }
+    /** The effective entry for a tag (the last one in the index), or `null`. */
+    entry(tagArg) {
+        let found = this.lookup.get(tagArg);
+        if (found === undefined) {
+            found = null;
+            for (let i = this.entryCount - 1; i >= 0; i--) {
+                if (this.tagAt(i) === tagArg) {
+                    found = this.entryAt(i);
+                    break;
+                }
+            }
+            this.lookup.set(tagArg, found);
+        }
+        return found;
+    }
+    /** The index positions of every effective entry (the last one per tag), in ascending tag order. */
+    effectiveIndexes() {
+        const order = new Uint32Array(this.entryCount);
+        for (let i = 0; i < order.length; i++) {
+            order[i] = i;
+        }
+        order.sort((a, b) => this.tagAt(a) - this.tagAt(b) || a - b);
+        // within one tag the positions ascend: keep the last of each run
+        let kept = 0;
+        for (let i = 0; i < order.length; i++) {
+            if (i + 1 === order.length || this.tagAt(order[i + 1]) !== this.tagAt(order[i])) {
+                order[kept++] = order[i];
+            }
+        }
+        return order.subarray(0, kept);
+    }
+    contents(entryArg) {
+        return this.data.subarray(entryArg.start, entryArg.end);
+    }
+    /**
+     * go-rpmutils `GetStrings` on the raw bytes: `null` when the tag is absent
+     * or not a string type. A negative count (a Go slice panic) is
+     * `malformed-header`; more values than `maxEntries` is `limit-exceeded`.
+     */
+    strings(tagArg) {
+        const entry = this.entry(tagArg);
+        if (entry === null ||
+            (entry.type !== RPM_TYPE.string && entry.type !== RPM_TYPE.stringArray && entry.type !== RPM_TYPE.i18nString)) {
+            return null;
+        }
+        if (entry.count < 0) {
+            throw new LinuxRepoError('malformed-header', `RPM tag ${tagArg} has a negative count`, { field: `tag ${tagArg}` });
+        }
+        this.assertCount(entry);
+        const values = [];
+        const contents = this.contents(entry);
+        let offset = 0;
+        for (let i = 0; i < entry.count; i++) {
+            const nul = contents.indexOf(0, offset);
+            values.push(contents.subarray(offset, nul));
+            offset = nul + 1;
+        }
+        return values;
+    }
+    /** go-rpmutils `getInts`: `null` when the tag is absent or not an integer type. */
+    integers(tagArg) {
+        const entry = this.entry(tagArg);
+        if (entry === null) {
+            return null;
+        }
+        let width;
+        switch (entry.type) {
+            case RPM_TYPE.char:
+            case RPM_TYPE.int8:
+                width = 1;
+                break;
+            case RPM_TYPE.int16:
+                width = 2;
+                break;
+            case RPM_TYPE.int32:
+                width = 4;
+                break;
+            case RPM_TYPE.int64:
+                width = 8;
+                break;
+            default:
+                return null;
+        }
+        this.assertCount(entry);
+        const contents = this.contents(entry);
+        const view = new DataView(contents.buffer, contents.byteOffset, contents.byteLength);
+        const values = [];
+        for (let offset = 0; offset + width <= contents.length; offset += width) {
+            values.push(width === 1
+                ? BigInt(view.getUint8(offset))
+                : width === 2
+                    ? BigInt(view.getUint16(offset))
+                    : width === 4
+                        ? BigInt(view.getUint32(offset))
+                        : view.getBigUint64(offset));
+        }
+        return { width, values };
+    }
+    /** go-rpmutils `GetUint32s`: `null` when absent, not an integer type, or 64-bit. */
+    uint32s(tagArg) {
+        const integers = this.integers(tagArg);
+        if (integers === null || integers.width === 8) {
+            return null;
+        }
+        return integers.values.map(Number);
+    }
+    /** go-rpmutils `GetUint64s`: `null` when absent or not an integer type. */
+    uint64s(tagArg) {
+        return this.integers(tagArg)?.values ?? null;
+    }
+    /** go-rpmutils `GetBytes`: `null` when absent or not binary. */
+    binary(tagArg) {
+        const entry = this.entry(tagArg);
+        return entry === null || entry.type !== RPM_TYPE.bin ? null : this.contents(entry);
+    }
+    assertCount(entryArg) {
+        if (entryArg.count > this.maxEntries) {
+            throw limitExceeded('maxEntries', this.maxEntries, `RPM tag ${entryArg.tag}`);
+        }
+    }
+}
+/**
+ * Reads the lead, the signature header and the main header from `readerArg`
+ * and checks the main header digest. The signature header plus the main
+ * header count against `maxMetadataBytes`. The reader is left at the payload.
+ */
+export async function readRpmHeaders(readerArg, limitsArg) {
+    const lead = await readUpTo(readerArg, RPM_LEAD_BYTES);
+    const magicLength = Math.min(lead.length, LEAD_MAGIC.length);
+    for (let i = 0; i < magicLength; i++) {
+        if (lead[i] !== LEAD_MAGIC[i]) {
+            throw new LinuxRepoError('unsupported-package-format', 'the input is not an RPM package (bad lead magic)', {
+                field: 'lead',
+            });
+        }
+    }
+    if (lead.length < RPM_LEAD_BYTES) {
+        throw truncated('RPM lead');
+    }
+    const isSource = ((lead[6] << 8) | lead[7]) === 1;
+    const signature = await readHeader(readerArg, limitsArg, 0, true, 'RPM signature header');
+    const main = await readHeader(readerArg, limitsArg, signature.bytes.length, false, 'RPM main header');
+    checkMainHeaderDigest(signature, main);
+    const mainStart = RPM_LEAD_BYTES + signature.bytes.length;
+    return { lead, isSource, signature, main, mainStart };
+}
+async function readHeader(readerArg, limitsArg, alreadyReadArg, isSignatureArg, whatArg) {
+    const intro = await readExact(readerArg, HEADER_INTRO_BYTES, whatArg);
+    const introView = new DataView(intro.buffer, intro.byteOffset, intro.byteLength);
+    if (introView.getUint32(0) !== HEADER_MAGIC) {
+        throw new LinuxRepoError('malformed-header', `bad magic for the ${whatArg}`, { field: whatArg });
+    }
+    const indexCount = introView.getUint32(8);
+    const dataLength = introView.getUint32(12);
+    // go-rpmutils computes both in uint32: a wrapped index size cannot hold
+    // `indexCount` entries, and a wrapped padded size reads that many bytes
+    if (indexCount * INDEX_ENTRY_BYTES > 0xffffffff) {
+        throw new LinuxRepoError('malformed-header', `the ${whatArg} index is too large`, { field: whatArg });
+    }
+    const readLength = isSignatureArg ? ((dataLength + 7) & 0xfffffff8) >>> 0 : dataLength;
+    const total = HEADER_INTRO_BYTES + indexCount * INDEX_ENTRY_BYTES + readLength;
+    if (alreadyReadArg + total > limitsArg.maxMetadataBytes) {
+        throw limitExceeded('maxMetadataBytes', limitsArg.maxMetadataBytes, 'the RPM signature and main headers');
+    }
+    // one buffer for the whole header, filled in place
+    const bytes = new Uint8Array(total);
+    bytes.set(intro, 0);
+    for (let filled = HEADER_INTRO_BYTES; filled < total;) {
+        const chunk = await readerArg.read(total - filled);
+        if (chunk === null) {
+            throw truncated(whatArg);
+        }
+        bytes.set(chunk, filled);
+        filled += chunk.length;
+    }
+    const dataStart = HEADER_INTRO_BYTES + indexCount * INDEX_ENTRY_BYTES;
+    return new RpmHeader(bytes, parseIndex(bytes, indexCount, dataStart, whatArg), dataStart, limitsArg.maxEntries);
+}
+/** Checks every index entry against the data and returns the end of each entry's contents. */
+function parseIndex(bytesArg, indexCountArg, dataStartArg, whatArg) {
+    const view = new DataView(bytesArg.buffer, bytesArg.byteOffset, bytesArg.byteLength);
+    const data = bytesArg.subarray(dataStartArg);
+    const nuls = new NulIndex(data);
+    // an end lies inside the data, whose length is a uint32
+    const ends = new Uint32Array(indexCountArg);
+    for (let i = 0; i < indexCountArg; i++) {
+        const at = HEADER_INTRO_BYTES + i * INDEX_ENTRY_BYTES;
+        const tag = view.getInt32(at);
+        const type = view.getInt32(at + 4);
+        const offset = view.getInt32(at + 8);
+        const count = view.getInt32(at + 12);
+        const size = TYPE_SIZES.get(type);
+        let end;
+        if (size !== undefined) {
+            end = offset + size * count;
+        }
+        else if (count > 0) {
+            // the `count` strings must each end in a NUL inside the data
+            end = offset < 0 || offset > data.length ? -1 : nuls.endOfStrings(offset, count);
+            if (end < 0) {
+                throw new LinuxRepoError('malformed-header', `${whatArg} tag ${tag} is truncated`, { field: `tag ${tag}` });
+            }
+        }
+        else {
+            end = offset;
+        }
+        if (offset < 0 || end < offset || end > data.length) {
+            throw new LinuxRepoError('malformed-header', `${whatArg} tag ${tag} lies outside the header data`, {
+                field: `tag ${tag}`,
+            });
+        }
+        ends[i] = end;
+    }
+    return ends;
+}
+const NUL_BLOCK_BYTES = 4096;
+const NUL_SUBBLOCK_BYTES = 64;
+const SUBBLOCKS_PER_BLOCK = NUL_BLOCK_BYTES / NUL_SUBBLOCK_BYTES;
+/**
+ * A rank directory over the NUL bytes of a header's data, built on first use,
+ * so that finding the end of `count` strings costs two binary searches and
+ * two scans of at most 64 bytes instead of a scan per entry (a crafted index
+ * can point many entries at one long run). It holds the NULs before every
+ * 4 KiB block (4 bytes each) and, relative to its block, before every 64-byte
+ * sub-block (2 bytes each): about 3% of the data, however many NULs it holds.
+ */
+class NulIndex {
+    data;
+    directory = null;
+    constructor(data) {
+        this.data = data;
+    }
+    /** The offset just past the `countArg`-th NUL at or after `offsetArg` (`0 <= offsetArg <= data.length`), or -1. */
+    endOfStrings(offsetArg, countArg) {
+        if (offsetArg >= this.data.length) {
+            return -1;
+        }
+        if (countArg === 1) {
+            // a short string ends within one block; a longer one goes through the
+            // directory, so entries pointing into one long run never rescan it
+            const window = this.data.subarray(offsetArg, offsetArg + NUL_BLOCK_BYTES + 1);
+            const nul = window.indexOf(0);
+            if (nul >= 0) {
+                return offsetArg + nul + 1;
+            }
+            if (offsetArg + window.length === this.data.length) {
+                return -1;
+            }
+        }
+        const directory = this.build();
+        // the NUL wanted is the one with `rank` NULs before it
+        const rank = this.rank(directory, offsetArg) + countArg - 1;
+        return rank < directory.total ? this.select(directory, rank) + 1 : -1;
+    }
+    /** The number of NULs before `offsetArg` (`offsetArg < data.length`). */
+    rank(directoryArg, offsetArg) {
+        const subblock = Math.floor(offsetArg / NUL_SUBBLOCK_BYTES);
+        let rank = directoryArg.blocks[Math.floor(offsetArg / NUL_BLOCK_BYTES)] + directoryArg.subblocks[subblock];
+        for (let i = subblock * NUL_SUBBLOCK_BYTES; i < offsetArg; i++) {
+            if (this.data[i] === 0) {
+                rank++;
+            }
+        }
+        return rank;
+    }
+    /** The position of the NUL with `rankArg` NULs before it (`rankArg` below the total). */
+    select(directoryArg, rankArg) {
+        const { blocks, subblocks } = directoryArg;
+        // the last block with at most `rankArg` NULs before it
+        let low = 0;
+        let high = blocks.length - 1;
+        while (low < high) {
+            const middle = (low + high + 1) >>> 1;
+            if (blocks[middle] <= rankArg) {
+                low = middle;
+            }
+            else {
+                high = middle - 1;
+            }
+        }
+        let remaining = rankArg - blocks[low];
+        // the last sub-block of that block with at most `remaining` NULs before it in the block
+        high = Math.min(subblocks.length, (low + 1) * SUBBLOCKS_PER_BLOCK) - 1;
+        low *= SUBBLOCKS_PER_BLOCK;
+        while (low < high) {
+            const middle = (low + high + 1) >>> 1;
+            if (subblocks[middle] <= remaining) {
+                low = middle;
+            }
+            else {
+                high = middle - 1;
+            }
+        }
+        remaining -= subblocks[low];
+        for (let i = low * NUL_SUBBLOCK_BYTES, end = Math.min(this.data.length, i + NUL_SUBBLOCK_BYTES); i < end; i++) {
+            if (this.data[i] === 0 && remaining-- === 0) {
+                return i;
+            }
+        }
+        // unreachable while the directory matches the data: a codec fault, not a verdict on the package
+        throw new Error('the RPM header NUL directory does not match the header data');
+    }
+    build() {
+        if (this.directory === null) {
+            const data = this.data;
+            const blocks = new Uint32Array(Math.ceil(data.length / NUL_BLOCK_BYTES));
+            const subblocks = new Uint16Array(Math.ceil(data.length / NUL_SUBBLOCK_BYTES));
+            let total = 0;
+            let inBlock = 0;
+            for (let i = 0; i < data.length; i++) {
+                if (i % NUL_SUBBLOCK_BYTES === 0) {
+                    if (i % NUL_BLOCK_BYTES === 0) {
+                        blocks[i / NUL_BLOCK_BYTES] = total;
+                        inBlock = 0;
+                    }
+                    subblocks[i / NUL_SUBBLOCK_BYTES] = inBlock;
+                }
+                if (data[i] === 0) {
+                    total++;
+                    inBlock++;
+                }
+            }
+            this.directory = { blocks, subblocks, total };
+        }
+        return this.directory;
+    }
+}
+/**
+ * go-rpmutils `getHashAndType` + the check in `readHeader`: the SHA-256 tag
+ * when it is a non-empty string, else the SHA-1 tag; a value of one character
+ * or less disables the check.
+ */
+function checkMainHeaderDigest(signatureArg, mainArg) {
+    let expected = firstString(signatureArg, RPM_SIGNATURE_TAG.sha256);
+    let algorithm = 'sha256';
+    if (expected === null || expected.length === 0) {
+        expected = firstString(signatureArg, RPM_SIGNATURE_TAG.sha1);
+        algorithm = 'sha1';
+    }
+    if (expected === null || expected.length <= 1) {
+        return;
+    }
+    const actual = new TextEncoder().encode(plugins.crypto.createHash(algorithm).update(mainArg.bytes).digest('hex'));
+    if (actual.length !== expected.length || actual.some((byte, i) => byte !== expected[i])) {
+        throw new LinuxRepoError('digest-mismatch', `the RPM main header does not match its ${algorithm.toUpperCase()} digest`, {
+            field: algorithm === 'sha256' ? 'tag 273' : 'tag 269',
+        });
+    }
+}
+/** go-rpmutils `getSha256`/`getSha1`: `vals[0]` panics on an empty array. */
+function firstString(headerArg, tagArg) {
+    const values = headerArg.strings(tagArg);
+    if (values === null) {
+        return null;
+    }
+    if (values.length === 0) {
+        throw new LinuxRepoError('malformed-header', `RPM signature tag ${tagArg} holds no value`, { field: `tag ${tagArg}` });
+    }
+    return values[0];
+}
+/**
+ * Serializes a signature header as go-rpmutils `WriteTo(…, 62)` does
+ * (`writeheader.go:66-123`): entries below tag 64 are dropped, the rest are
+ * written in ascending tag order with INT16/32/64 data aligned, the region
+ * tag 62 comes first in the index with its 16-byte trailer as the last data
+ * item, and the whole header is padded to 8 bytes.
+ *
+ * The entries are the effective entries of `sourceArg` whose tags are not in
+ * `removedArg`, copied without an object per entry, and `addedArg`, whose
+ * tags must be in `removedArg`.
+ */
+export function writeSignatureHeader(sourceArg, removedArg, addedArg) {
+    const kept = sourceArg.effectiveIndexes();
+    let keptCount = 0;
+    for (const indexValue of kept) {
+        const tag = sourceArg.tagAt(indexValue);
+        if (tag >= RPM_TAG_HEADER_REGIONS && !removedArg.has(tag)) {
+            kept[keptCount++] = indexValue;
+        }
+    }
+    const added = addedArg.filter((entry) => entry.tag >= RPM_TAG_HEADER_REGIONS).sort((a, b) => a.tag - b.tag);
+    /** Calls `visitArg` for every entry in ascending tag order, with the offset of its data. */
+    const layout = (visitArg) => {
+        let dataLength = 0;
+        for (let k = 0, a = 0; k < keptCount || a < added.length;) {
+            let entry;
+            let contents = null;
+            if (a < added.length && (k === keptCount || added[a].tag < sourceArg.tagAt(kept[k]))) {
+                const item = added[a++];
+                entry = { tag: item.tag, type: item.type, count: item.count, start: 0, end: item.contents.length };
+                contents = item.contents;
+            }
+            else {
+                entry = sourceArg.entryAt(kept[k++]);
+            }
+            const alignment = TYPE_ALIGNMENT.get(entry.type);
+            if (alignment !== undefined && dataLength % alignment !== 0) {
+                dataLength += alignment - (dataLength % alignment);
+            }
+            visitArg(entry, contents, dataLength);
+            dataLength += entry.end - entry.start;
+        }
+        return dataLength;
+    };
+    const trailerOffset = layout(() => undefined);
+    const dataLength = trailerOffset + INDEX_ENTRY_BYTES;
+    const indexCount = keptCount + added.length + 1;
+    const unpadded = HEADER_INTRO_BYTES + indexCount * INDEX_ENTRY_BYTES + dataLength;
+    const bytes = new Uint8Array(unpadded + ((8 - (dataLength % 8)) % 8));
+    const view = new DataView(bytes.buffer);
+    view.setUint32(0, HEADER_MAGIC);
+    view.setUint32(8, indexCount);
+    view.setUint32(12, dataLength);
+    const dataStart = HEADER_INTRO_BYTES + indexCount * INDEX_ENTRY_BYTES;
+    const writeIndex = (indexArg, tagArg, typeArg, offsetArg, countArg) => {
+        const at = HEADER_INTRO_BYTES + indexArg * INDEX_ENTRY_BYTES;
+        view.setInt32(at, tagArg);
+        view.setInt32(at + 4, typeArg);
+        view.setInt32(at + 8, offsetArg);
+        view.setInt32(at + 12, countArg);
+    };
+    writeIndex(0, RPM_SIGNATURE_TAG.headerSignatures, RPM_TYPE.bin, trailerOffset, INDEX_ENTRY_BYTES);
+    let written = 1;
+    layout((entryArg, contentsArg, offsetArg) => {
+        writeIndex(written++, entryArg.tag, entryArg.type, offsetArg, entryArg.count);
+        if (entryArg.end > entryArg.start) {
+            bytes.set(contentsArg ?? sourceArg.contents(entryArg), dataStart + offsetArg);
+        }
+    });
+    const trailer = dataStart + trailerOffset;
+    view.setInt32(trailer, RPM_SIGNATURE_TAG.headerSignatures);
+    view.setInt32(trailer + 4, RPM_TYPE.bin);
+    view.setInt32(trailer + 8, -INDEX_ENTRY_BYTES * indexCount);
+    view.setInt32(trailer + 12, INDEX_ENTRY_BYTES);
+    return bytes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header.js","sourceRoot":"","sources":["../../ts/rpm/header.ts"],"names":[],"mappings":"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"}

package/dist_ts/rpm/reader.d.ts

@@ -0,0 +1,20 @@
+import { type ILinuxPackageLimits } from '../shared/limits.js';
+import type { IRpmPackageRecord } from '../shared/types.js';
+/**
+ * Reads an RPM package into a record holding exactly what Gitea 28.2.0's
+ * `rpm.ParsePackage` derives (`modules/packages/rpm/metadata.go:102-299`),
+ * plus the digests of the whole file.
+ *
+ * Gitea reads only the lead and the two headers; so does the reader, which
+ * then drains the payload for the digests. The differences from Gitea:
+ * `installedSize` falls back to LONGSIZE (5009) and `archiveSize` to the
+ * signature tag LONGARCHIVESIZE (271) when the 32-bit tag gives no value;
+ * numbers above `Number.MAX_SAFE_INTEGER`, tags with more than `maxEntries`
+ * values, and a NAME or built version that is not a path segment (empty,
+ * `.`, `..`, or holding `/` or a control character) are refused. Strings are decoded with the shared
+ * Go-compatible decoder (each byte of an invalid UTF-8 sequence becomes
+ * U+FFFD); Gitea 28.2.0 refuses such packages because its JSON v2 encoder
+ * rejects invalid UTF-8; the codec accepts them, so it accepts a superset of
+ * what Gitea accepts.
+ */
+export declare function readRpmPackage(source: AsyncIterable<Uint8Array>, limits?: Partial<ILinuxPackageLimits>): Promise<IRpmPackageRecord>;