@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/dist_ts/rpm/sign.js

@@ -0,0 +1,183 @@
+import * as plugins from '../plugins.js';
+import { PackageByteSource } from '../readers/bytesource.js';
+import { READ_CHUNK_BYTES } from '../readers/bytes.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { resolveLinuxPackageLimits } from '../shared/limits.js';
+import { assertTimestamp } from '../shared/validation.js';
+import { createDetachedBinarySignature } from '../signing/openpgpframing.js';
+import { singleChunk } from '../signing/signers.js';
+import { readRpmHeaders, RPM_SIGNATURE_TAG, RPM_TYPE, writeSignatureHeader } from './header.js';
+const PAYLOAD_DIGEST = 5092;
+const PAYLOAD_DIGEST_ALGORITHM = 5093;
+/** go-rpmutils `getPayloadDigest` algorithms (`signatures.go`, RFC 4880 ids). */
+const PAYLOAD_DIGEST_ALGORITHMS = new Map([
+    [1, 'md5'],
+    [2, 'sha1'],
+    [8, 'sha256'],
+    [9, 'sha384'],
+    [10, 'sha512'],
+    [11, 'sha224'],
+]);
+/**
+ * Signs an RPM package as Gitea 28.2.0 does on upload (`services/packages/rpm/sign.go:17-38`,
+ * go-rpmutils v0.4.0 `SignRpmStream` and `DumpSignatureHeader(false)`):
+ * - the main header digest is checked, and the payload is checked against
+ *   PAYLOADDIGEST (5092/5093), else the signature header MD5 (1004) over
+ *   header and payload; a package with neither is `missing-field`, a mismatch
+ *   `digest-mismatch`;
+ * - tag 1002 gets a signature over the main header and payload, tag 268 one
+ *   over the main header alone; tags 1005, 267 and 1008 are removed; every
+ *   other signature tag from 64 up is kept byte for byte, the tags are written
+ *   in ascending order behind a new region tag 62, and the header is padded to
+ *   8 bytes.
+ *
+ * The signed package is `prefix` (the lead and the new signature header)
+ * followed by the original bytes from `resumeAt`, the start of the main
+ * header. The source is read once; only the headers are held in memory, and
+ * the payload streams through the signer. A signer that returns before reading
+ * the data to its end is `signing-failed`.
+ */
+export async function signRpmPackage(input) {
+    if (input === null || typeof input !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    if (input.signer === null || typeof input.signer !== 'object' || typeof input.signer.signBinary !== 'function') {
+        throw new LinuxRepoError('invalid-input', 'signer must implement IOpenPgpSigner', { field: 'signer' });
+    }
+    assertTimestamp(input.timestamp);
+    const limits = resolveLinuxPackageLimits(input.limits);
+    const bytes = new PackageByteSource(input.source, limits.maxPackageBytes);
+    const headers = await readRpmHeaders(bytes, limits);
+    const payloadCheck = payloadDigestCheck(headers);
+    const signedData = new SignedDataStream(headers.main.bytes, bytes, payloadCheck);
+    let headerAndPayload;
+    try {
+        headerAndPayload = await createDetachedBinarySignature({ data: signedData, signer: input.signer, timestamp: input.timestamp });
+    }
+    catch (error) {
+        // a failure of the codec's own stream (or the caller's source) wins over what the signer made of it
+        throw signedData.failure !== undefined ? signedData.failure.error : error;
+    }
+    if (signedData.failure !== undefined) {
+        throw signedData.failure.error;
+    }
+    if (!signedData.completed) {
+        throw new LinuxRepoError('signing-failed', 'the signer returned before reading the package to its end', { field: 'signer' });
+    }
+    const headerOnly = await createDetachedBinarySignature({
+        data: singleChunk(headers.main.bytes),
+        signer: input.signer,
+        timestamp: input.timestamp,
+    });
+    const removed = new Set([
+        RPM_SIGNATURE_TAG.pgp,
+        RPM_SIGNATURE_TAG.rsa,
+        RPM_SIGNATURE_TAG.gpg,
+        RPM_SIGNATURE_TAG.dsa,
+        RPM_SIGNATURE_TAG.reservedSpace,
+    ]);
+    const signatureHeader = writeSignatureHeader(headers.signature, removed, [
+        { tag: RPM_SIGNATURE_TAG.pgp, type: RPM_TYPE.bin, count: headerAndPayload.length, contents: headerAndPayload },
+        { tag: RPM_SIGNATURE_TAG.rsa, type: RPM_TYPE.bin, count: headerOnly.length, contents: headerOnly },
+    ]);
+    const prefix = new Uint8Array(headers.lead.length + signatureHeader.length);
+    prefix.set(headers.lead, 0);
+    prefix.set(signatureHeader, headers.lead.length);
+    return { prefix, resumeAt: headers.mainStart };
+}
+function payloadDigestCheck(headersArg) {
+    // the same lookups, in the same order, as go-rpmutils `getPayloadDigest`
+    const digests = headersArg.main.strings(PAYLOAD_DIGEST);
+    const algorithms = digests === null || digests.length === 0 ? null : headersArg.main.uint32s(PAYLOAD_DIGEST_ALGORITHM);
+    const algorithm = algorithms === null || algorithms.length === 0 ? undefined : PAYLOAD_DIGEST_ALGORITHMS.get(algorithms[0]);
+    if (algorithm !== undefined && digests !== null) {
+        const expected = digests[0];
+        return {
+            hash: plugins.crypto.createHash(algorithm),
+            coversHeader: false,
+            matches: (digestArg) => {
+                const actual = new TextEncoder().encode(digestArg.toString('hex'));
+                return actual.length === expected.length && actual.every((byte, i) => byte === expected[i]);
+            },
+        };
+    }
+    const md5 = headersArg.signature.binary(RPM_SIGNATURE_TAG.md5);
+    if (md5 !== null && md5.length !== 0) {
+        return {
+            hash: plugins.crypto.createHash('md5'),
+            coversHeader: true,
+            matches: (digestArg) => digestArg.length === md5.length && digestArg.every((byte, i) => byte === md5[i]),
+        };
+    }
+    throw new LinuxRepoError('missing-field', 'the RPM package has no usable payload digest', { field: 'payload digest' });
+}
+/**
+ * The data tag 1002 signs: the main header, then the payload as it is pulled
+ * from the package source, hashed for the payload check on the way. Iterable
+ * once; it pulls only when the signer asks. Any failure (the caller's source,
+ * a limit, truncation, a digest mismatch) is thrown to the signer and kept, so
+ * `signRpmPackage` reports it instead of whatever the signer made of it.
+ */
+class SignedDataStream {
+    mainHeader;
+    source;
+    check;
+    completed = false;
+    failure = undefined;
+    iterated = false;
+    headerSent = false;
+    queue = Promise.resolve();
+    constructor(mainHeader, source, check) {
+        this.mainHeader = mainHeader;
+        this.source = source;
+        this.check = check;
+    }
+    [Symbol.asyncIterator]() {
+        if (this.iterated) {
+            const error = new LinuxRepoError('signing-failed', 'the signer read the package data more than once', { field: 'signer' });
+            this.failure ??= { error };
+            throw error;
+        }
+        this.iterated = true;
+        return {
+            next: () => {
+                // serialize: a signer that does not await one next() before the next one still gets the bytes in order
+                const result = this.queue.then(() => this.pull());
+                this.queue = result.catch(() => undefined);
+                return result;
+            },
+        };
+    }
+    async pull() {
+        if (this.failure !== undefined) {
+            throw this.failure.error;
+        }
+        if (this.completed) {
+            return { done: true, value: undefined };
+        }
+        try {
+            if (!this.headerSent) {
+                this.headerSent = true;
+                if (this.check.coversHeader) {
+                    this.check.hash.update(this.mainHeader);
+                }
+                return { done: false, value: this.mainHeader };
+            }
+            const chunk = await this.source.read(READ_CHUNK_BYTES);
+            if (chunk !== null) {
+                this.check.hash.update(chunk);
+                return { done: false, value: chunk };
+            }
+            if (!this.check.matches(this.check.hash.digest())) {
+                throw new LinuxRepoError('digest-mismatch', 'the RPM payload does not match its digest', { field: 'payload digest' });
+            }
+            this.completed = true;
+            return { done: true, value: undefined };
+        }
+        catch (error) {
+            this.failure = { error };
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign.js","sourceRoot":"","sources":["../../ts/rpm/sign.ts"],"names":[],"mappings":"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"}

package/dist_ts/rpm/updates.d.ts

@@ -0,0 +1,38 @@
+import type { IRpmUpdate } from '../shared/types.js';
+/**
+ * Merges posted errata into the stored ones, as Gitea 28.2.0's errata route
+ * does (`routers/api/packages/rpm/rpm.go:367-447`). Pure: the inputs are
+ * never changed, and incoming updates are applied in order.
+ * - A known id: its collections merge by `short` and its packages are
+ *   de-duplicated by name, version, release and arch; the seven scalar fields
+ *   and `references` are replaced; `updated` becomes the timestamp and
+ *   `issued` is kept.
+ * - A new id: the update is appended; `issued` and `updated` get the
+ *   timestamp only when they are `null`.
+ * - De-duplication applies to every append, including the collections of a new
+ *   update (Gitea appends those as posted).
+ * Dates are written as `YYYY-MM-DD HH:MM:SS` in UTC (Gitea uses its server's
+ * local time). Contents are not validated, as in Gitea; only the shape is.
+ */
+export declare function mergeRpmUpdates(input: {
+    existing: IRpmUpdate[];
+    incoming: IRpmUpdate[];
+    timestamp: Date;
+}): IRpmUpdate[];
+/**
+ * The updates of an index: updates with the same id merge as
+ * Gitea's `buildUpdateInfo` does (`services/packages/rpm/repository.go:560-620`),
+ * without setting any date. The scalar fields, dates and references come from
+ * the update with the newest `updated`, then the newest `issued`, then the
+ * greatest canonical JSON of those fields; packages that collide keep the
+ * values of the higher-ranked update. Updates sort by id, collections by
+ * `short`, packages by name, version, release and arch; references keep their
+ * order. The input order never decides.
+ */
+export declare function combineRpmUpdates(updatesArg: IRpmUpdate[]): IRpmUpdate[];
+/** `updateinfo.xml` for combined updates, as Go's `encoding/xml` writes Gitea's `Update` type. */
+export declare function renderUpdateInfo(updatesArg: IRpmUpdate[]): string;
+/** `YYYY-MM-DD HH:MM:SS` in UTC. */
+export declare function formatRpmUpdateDate(timestampArg: Date): string;
+/** Refuses anything that is not an array of plain-JSON `IRpmUpdate` values. */
+export declare function assertRpmUpdates(valueArg: unknown, fieldArg: string): asserts valueArg is IRpmUpdate[];

package/dist_ts/rpm/updates.js

@@ -0,0 +1,265 @@
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertTimestamp } from '../shared/validation.js';
+import { compareCodePoints, element, textElement, XML_HEADER } from './xml.js';
+/**
+ * Merges posted errata into the stored ones, as Gitea 28.2.0's errata route
+ * does (`routers/api/packages/rpm/rpm.go:367-447`). Pure: the inputs are
+ * never changed, and incoming updates are applied in order.
+ * - A known id: its collections merge by `short` and its packages are
+ *   de-duplicated by name, version, release and arch; the seven scalar fields
+ *   and `references` are replaced; `updated` becomes the timestamp and
+ *   `issued` is kept.
+ * - A new id: the update is appended; `issued` and `updated` get the
+ *   timestamp only when they are `null`.
+ * - De-duplication applies to every append, including the collections of a new
+ *   update (Gitea appends those as posted).
+ * Dates are written as `YYYY-MM-DD HH:MM:SS` in UTC (Gitea uses its server's
+ * local time). Contents are not validated, as in Gitea; only the shape is.
+ */
+export function mergeRpmUpdates(input) {
+    if (input === null || typeof input !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    assertRpmUpdates(input.existing, 'existing');
+    assertRpmUpdates(input.incoming, 'incoming');
+    assertTimestamp(input.timestamp);
+    const now = formatRpmUpdateDate(input.timestamp);
+    const merged = input.existing.map(cloneUpdate);
+    for (const incoming of input.incoming) {
+        const update = cloneUpdate(incoming);
+        const known = merged.find((candidate) => candidate.id === update.id);
+        if (known !== undefined) {
+            mergeCollections(known.collections, update.collections);
+            known.from = update.from;
+            known.status = update.status;
+            known.type = update.type;
+            known.version = update.version;
+            known.title = update.title;
+            known.severity = update.severity;
+            known.description = update.description;
+            known.references = update.references;
+            known.updated = now;
+        }
+        else {
+            const appended = { ...update, issued: update.issued ?? now, updated: update.updated ?? now, collections: [] };
+            mergeCollections(appended.collections, update.collections);
+            merged.push(appended);
+        }
+    }
+    return merged;
+}
+/**
+ * The updates of an index: updates with the same id merge as
+ * Gitea's `buildUpdateInfo` does (`services/packages/rpm/repository.go:560-620`),
+ * without setting any date. The scalar fields, dates and references come from
+ * the update with the newest `updated`, then the newest `issued`, then the
+ * greatest canonical JSON of those fields; packages that collide keep the
+ * values of the higher-ranked update. Updates sort by id, collections by
+ * `short`, packages by name, version, release and arch; references keep their
+ * order. The input order never decides.
+ */
+export function combineRpmUpdates(updatesArg) {
+    const byId = new Map();
+    for (const update of updatesArg) {
+        const group = byId.get(update.id);
+        if (group === undefined) {
+            byId.set(update.id, [update]);
+        }
+        else {
+            group.push(update);
+        }
+    }
+    const combined = [];
+    for (const group of byId.values()) {
+        const ranked = [...group].sort(compareRank);
+        const result = { ...cloneUpdate(ranked[0]), collections: [] };
+        for (const update of ranked) {
+            mergeCollections(result.collections, update.collections.map(cloneCollection));
+        }
+        result.collections.sort((a, b) => compareCodePoints(a.short, b.short));
+        for (const collection of result.collections) {
+            collection.packages.sort(comparePackages);
+        }
+        combined.push(result);
+    }
+    return combined.sort((a, b) => compareCodePoints(a.id, b.id));
+}
+/** `updateinfo.xml` for combined updates, as Go's `encoding/xml` writes Gitea's `Update` type. */
+export function renderUpdateInfo(updatesArg) {
+    const updates = updatesArg.map((update) => element('update', [
+        ['from', update.from],
+        ['status', update.status],
+        ['type', update.type],
+        ['version', update.version],
+    ], [
+        textElement('id', update.id),
+        textElement('title', update.title),
+        textElement('severity', update.severity),
+        textElement('description', update.description),
+        update.issued === null ? '' : element('issued', [['date', update.issued]]),
+        update.updated === null ? '' : element('updated', [['date', update.updated]]),
+        element('references', [], update.references
+            .map((reference) => element('reference', [
+            ['href', reference.href],
+            ['id', reference.id],
+            ['title', reference.title],
+            ['type', reference.type],
+        ]))
+            .join('')),
+        element('pkglist', [], update.collections
+            .map((collection) => element('collection', [['short', collection.short]], collection.packages
+            .map((pkg) => element('package', [
+            ['arch', pkg.arch],
+            ['name', pkg.name],
+            ['release', pkg.release],
+            ['src', pkg.src],
+            ['version', pkg.version],
+        ], textElement('filename', pkg.fileName)))
+            .join('')))
+            .join('')),
+    ].join('')));
+    return `${XML_HEADER}${element('updates', [['xmlns', 'http://linux.duke.edu/metadata/updateinfo']], updates.join(''))}`;
+}
+/** `YYYY-MM-DD HH:MM:SS` in UTC. */
+export function formatRpmUpdateDate(timestampArg) {
+    return timestampArg.toISOString().slice(0, 19).replace('T', ' ');
+}
+/** Refuses anything that is not an array of plain-JSON `IRpmUpdate` values. */
+export function assertRpmUpdates(valueArg, fieldArg) {
+    if (!Array.isArray(valueArg)) {
+        throw new LinuxRepoError('invalid-input', `${fieldArg} must be an array of RPM updates`, { field: fieldArg });
+    }
+    valueArg.forEach((update, i) => {
+        const at = `${fieldArg}[${i}]`;
+        const record = assertObject(update, at);
+        for (const key of ['id', 'from', 'status', 'type', 'version', 'title', 'severity', 'description']) {
+            assertStringField(record, key, at);
+        }
+        for (const key of ['issued', 'updated']) {
+            if (record[key] !== null) {
+                assertStringField(record, key, at);
+            }
+        }
+        assertArrayField(record, 'references', at).forEach((reference, r) => {
+            const referenceRecord = assertObject(reference, `${at}.references[${r}]`);
+            for (const key of ['href', 'id', 'title', 'type']) {
+                assertStringField(referenceRecord, key, `${at}.references[${r}]`);
+            }
+        });
+        assertArrayField(record, 'collections', at).forEach((collection, c) => {
+            const collectionAt = `${at}.collections[${c}]`;
+            const collectionRecord = assertObject(collection, collectionAt);
+            assertStringField(collectionRecord, 'short', collectionAt);
+            assertArrayField(collectionRecord, 'packages', collectionAt).forEach((pkg, p) => {
+                const pkgRecord = assertObject(pkg, `${collectionAt}.packages[${p}]`);
+                for (const key of ['name', 'version', 'release', 'arch', 'src', 'fileName']) {
+                    assertStringField(pkgRecord, key, `${collectionAt}.packages[${p}]`);
+                }
+            });
+        });
+    });
+}
+function assertObject(valueArg, fieldArg) {
+    if (valueArg === null || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+        throw new LinuxRepoError('invalid-input', `${fieldArg} must be an object`, { field: fieldArg });
+    }
+    return valueArg;
+}
+function assertStringField(recordArg, keyArg, atArg) {
+    if (typeof recordArg[keyArg] !== 'string') {
+        throw new LinuxRepoError('invalid-input', `${atArg}.${keyArg} must be a string`, { field: `${atArg}.${keyArg}` });
+    }
+}
+function assertArrayField(recordArg, keyArg, atArg) {
+    const value = recordArg[keyArg];
+    if (!Array.isArray(value)) {
+        throw new LinuxRepoError('invalid-input', `${atArg}.${keyArg} must be an array`, { field: `${atArg}.${keyArg}` });
+    }
+    return value;
+}
+/** Merges `incomingArg` into `targetArg` by `short`, de-duplicating packages (mutates the target only). */
+function mergeCollections(targetArg, incomingArg) {
+    for (const collection of incomingArg) {
+        let target = targetArg.find((candidate) => candidate.short === collection.short);
+        if (target === undefined) {
+            target = { short: collection.short, packages: [] };
+            targetArg.push(target);
+        }
+        for (const pkg of collection.packages) {
+            if (!target.packages.some((candidate) => samePackage(candidate, pkg))) {
+                target.packages.push(clonePackage(pkg));
+            }
+        }
+    }
+}
+function samePackage(aArg, bArg) {
+    return aArg.name === bArg.name && aArg.version === bArg.version && aArg.release === bArg.release && aArg.arch === bArg.arch;
+}
+function comparePackages(aArg, bArg) {
+    return (compareCodePoints(aArg.name, bArg.name) ||
+        compareCodePoints(aArg.version, bArg.version) ||
+        compareCodePoints(aArg.release, bArg.release) ||
+        compareCodePoints(aArg.arch, bArg.arch));
+}
+/** Highest rank first: newest `updated`, newest `issued`, greatest canonical JSON. */
+function compareRank(aArg, bArg) {
+    return (compareNullableDesc(aArg.updated, bArg.updated) ||
+        compareNullableDesc(aArg.issued, bArg.issued) ||
+        compareCodePoints(canonicalScalars(bArg), canonicalScalars(aArg)));
+}
+function compareNullableDesc(aArg, bArg) {
+    if (aArg === bArg) {
+        return 0;
+    }
+    if (aArg === null) {
+        return 1;
+    }
+    if (bArg === null) {
+        return -1;
+    }
+    return compareCodePoints(bArg, aArg);
+}
+function canonicalScalars(updateArg) {
+    return JSON.stringify([
+        updateArg.from,
+        updateArg.status,
+        updateArg.type,
+        updateArg.version,
+        updateArg.title,
+        updateArg.severity,
+        updateArg.description,
+        updateArg.issued,
+        updateArg.updated,
+        updateArg.references.map((reference) => [reference.href, reference.id, reference.title, reference.type]),
+    ]);
+}
+function cloneUpdate(updateArg) {
+    return {
+        id: updateArg.id,
+        from: updateArg.from,
+        status: updateArg.status,
+        type: updateArg.type,
+        version: updateArg.version,
+        title: updateArg.title,
+        severity: updateArg.severity,
+        description: updateArg.description,
+        issued: updateArg.issued,
+        updated: updateArg.updated,
+        references: updateArg.references.map((reference) => ({ href: reference.href, id: reference.id, title: reference.title, type: reference.type })),
+        collections: updateArg.collections.map(cloneCollection),
+    };
+}
+function cloneCollection(collectionArg) {
+    return { short: collectionArg.short, packages: collectionArg.packages.map(clonePackage) };
+}
+function clonePackage(pkgArg) {
+    return {
+        name: pkgArg.name,
+        version: pkgArg.version,
+        release: pkgArg.release,
+        arch: pkgArg.arch,
+        src: pkgArg.src,
+        fileName: pkgArg.fileName,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"updates.js","sourceRoot":"","sources":["../../ts/rpm/updates.ts"],"names":[],"mappings":"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"}

package/dist_ts/rpm/xml.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The XML output of Go's `encoding/xml` as Gitea 28.2.0 uses it: the header
+ * `xml.Header`, no indentation, no self-closing elements, attributes in struct
+ * field order, and Go's escaping (`EscapeText`/`EscapeString`): `"` and `'`
+ * become numeric references, tab, line feed and carriage return are escaped,
+ * and a code point outside the XML character range becomes U+FFFD.
+ */
+export declare const XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+/** Go's escaping of character data and attribute values. */
+export declare function escapeXml(valueArg: string): string;
+/** Attributes in order; a value of `undefined` is omitted (Go's `omitempty` for an empty string is the caller's choice). */
+export type TXmlAttributes = Array<[string, string | number | undefined]>;
+/** `<name attr="…">content</name>`, where `contentArg` is already XML. */
+export declare function element(nameArg: string, attributesArg: TXmlAttributes, contentArg?: string): string;
+/** `<name>escaped text</name>`. */
+export declare function textElement(nameArg: string, textArg: string, attributesArg?: TXmlAttributes): string;
+/** Go's `strings.Compare`: UTF-8 byte order, which is code point order. */
+export declare function compareCodePoints(aArg: string, bArg: string): number;

package/dist_ts/rpm/xml.js

@@ -0,0 +1,90 @@
+/**
+ * The XML output of Go's `encoding/xml` as Gitea 28.2.0 uses it: the header
+ * `xml.Header`, no indentation, no self-closing elements, attributes in struct
+ * field order, and Go's escaping (`EscapeText`/`EscapeString`): `"` and `'`
+ * become numeric references, tab, line feed and carriage return are escaped,
+ * and a code point outside the XML character range becomes U+FFFD.
+ */
+export const XML_HEADER = '<?xml version="1.0" encoding="UTF-8"?>\n';
+const NEEDS_ESCAPE = /["'&<>\u0000-\u001f\ud800-\udfff\ufffe\uffff]/;
+/** Go's escaping of character data and attribute values. */
+export function escapeXml(valueArg) {
+    if (!NEEDS_ESCAPE.test(valueArg)) {
+        return valueArg;
+    }
+    let result = '';
+    for (const character of valueArg) {
+        const codePoint = character.codePointAt(0);
+        switch (character) {
+            case '"':
+                result += '&#34;';
+                break;
+            case "'":
+                result += '&#39;';
+                break;
+            case '&':
+                result += '&amp;';
+                break;
+            case '<':
+                result += '&lt;';
+                break;
+            case '>':
+                result += '&gt;';
+                break;
+            case '\t':
+                result += '&#x9;';
+                break;
+            case '\n':
+                result += '&#xA;';
+                break;
+            case '\r':
+                result += '&#xD;';
+                break;
+            default:
+                result += isXmlCharacter(codePoint) ? character : '\ufffd';
+        }
+    }
+    return result;
+}
+/** Go's `isInCharacterRange`. */
+function isXmlCharacter(codePointArg) {
+    return (codePointArg === 0x09 ||
+        codePointArg === 0x0a ||
+        codePointArg === 0x0d ||
+        (codePointArg >= 0x20 && codePointArg <= 0xd7ff) ||
+        (codePointArg >= 0xe000 && codePointArg <= 0xfffd) ||
+        (codePointArg >= 0x10000 && codePointArg <= 0x10ffff));
+}
+/** `<name attr="…">content</name>`, where `contentArg` is already XML. */
+export function element(nameArg, attributesArg, contentArg = '') {
+    let start = `<${nameArg}`;
+    for (const [attribute, value] of attributesArg) {
+        if (value !== undefined) {
+            start += ` ${attribute}="${escapeXml(String(value))}"`;
+        }
+    }
+    return `${start}>${contentArg}</${nameArg}>`;
+}
+/** `<name>escaped text</name>`. */
+export function textElement(nameArg, textArg, attributesArg = []) {
+    return element(nameArg, attributesArg, escapeXml(textArg));
+}
+/** Go's `strings.Compare`: UTF-8 byte order, which is code point order. */
+export function compareCodePoints(aArg, bArg) {
+    const length = Math.min(aArg.length, bArg.length);
+    for (let i = 0; i < length; i++) {
+        const a = aArg.charCodeAt(i);
+        const b = bArg.charCodeAt(i);
+        if (a !== b) {
+            // a surrogate (an astral code point) sorts after every other BMP unit
+            const aSurrogate = a >= 0xd800 && a <= 0xdfff;
+            const bSurrogate = b >= 0xd800 && b <= 0xdfff;
+            if (aSurrogate !== bSurrogate) {
+                return aSurrogate ? 1 : -1;
+            }
+            return a < b ? -1 : 1;
+        }
+    }
+    return aArg.length === bArg.length ? 0 : aArg.length < bArg.length ? -1 : 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/shared/architecture.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether an architecture can name an index path segment. Readers record any
+ * architecture a package states (Gitea accepts them); builders refuse an entry
+ * whose architecture fails this rule with `invalid-input`, and never skip it
+ * silently. Refused: the empty string, `.` and `..`, and any value containing
+ * `/`, whitespace or a control character.
+ */
+export declare function isIndexableArchitecture(architectureArg: string): boolean;