@push.rocks/smartlinuxrepo 0.0.0-stage → 1.0.0

package/.smartconfig.json

@@ -0,0 +1,65 @@
+{
+  "@git.zone/cli": {
+    "schemaVersion": 2,
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "smartlinuxrepo",
+      "description": "A pure codec for Linux package repositories (Alpine apk, Debian apt, RPM dnf, Arch pacman): read packages into records, build index file sets and sign them.",
+      "npmPackagename": "@push.rocks/smartlinuxrepo",
+      "license": "MIT",
+      "projectDomain": "push.rocks",
+      "keywords": [
+        "linux",
+        "package repository",
+        "alpine",
+        "apk",
+        "debian",
+        "apt",
+        "rpm",
+        "dnf",
+        "arch",
+        "pacman",
+        "openpgp",
+        "codec"
+      ]
+    },
+    "release": {
+      "confirmation": "prompt",
+      "versionFloor": "1.0.0",
+      "preflight": {
+        "requireCleanTree": true,
+        "test": false,
+        "build": true
+      },
+      "targets": {
+        "git": {
+          "enabled": true,
+          "remote": "origin",
+          "pushBranch": true,
+          "pushTags": true
+        },
+        "npm": {
+          "enabled": true,
+          "registries": [
+            "https://verdaccio.lossless.digital",
+            "https://registry.npmjs.org"
+          ],
+          "accessLevel": "public",
+          "alreadyPublished": "success"
+        },
+        "docker": {
+          "enabled": false,
+          "engine": "tsdocker",
+          "patterns": []
+        }
+      }
+    }
+  },
+  "@git.zone/tsrepo": {
+    "docs": {
+      "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license.md) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+    }
+  }
+}

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartlinuxrepo',
+    version: '1.0.0',
+    description: 'A pure codec for Linux package repositories (Alpine apk, Debian apt, RPM dnf, Arch pacman): read packages into records, build index file sets and sign them.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSw0QkFBNEI7SUFDbEMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDhKQUE4SjtDQUM1SyxDQUFBIn0=

package/dist_ts/alpine/apkindex.d.ts

@@ -0,0 +1,39 @@
+import type { IAlpinePackageRecord, ILinuxIndexFile } from '../shared/types.js';
+import type { IAlpineSigner } from '../signing/signers.js';
+/**
+ * Builds the `APKINDEX.tar.gz` set of one Alpine repository (one branch and
+ * repository) as Gitea 28.2.0 does (`services/packages/alpine/repository.go:150-351`):
+ * one index per architecture the entries name, at
+ * `{branch}/{repository}/{architecture}/APKINDEX.tar.gz`. Every index other
+ * than `noarch` also lists the `noarch` packages, and every block's `A:` is the
+ * index's architecture.
+ *
+ * Each archive is a signature gzip member (a tar entry
+ * `.SIGN.RSA.<signer.keyName>` holding RSA PKCS#1 v1.5 over SHA-1 of the
+ * unsigned stream, without an end-of-archive marker) followed by the unsigned
+ * gzip member (a tar entry `APKINDEX`, mode 0600, with the marker). Tar headers
+ * are byte-for-byte what Go `archive/tar` writes for Gitea (`writeGoTar`); the
+ * signature entry is padded to its 512-byte block (a difference from Gitea),
+ * which Gitea's 4096-bit signatures already fill exactly. Entries are sorted by name, version, architecture and file
+ * name (bytewise), so the bytes depend on the entry set, not its order.
+ *
+ * Pure: the signer is the only call out. `timestamp` is validated but not
+ * written; the format carries no build time. An empty entry set returns `[]`.
+ * Bad input is `invalid-input` and names the entry; an error from the signer
+ * propagates unchanged; a signer result that is not non-empty bytes is
+ * `signing-failed`.
+ */
+export declare function buildAlpineIndex(inputArg: {
+    branch: string;
+    repository: string;
+    entries: IAlpinePackageRecord[];
+    signer: IAlpineSigner;
+    timestamp: Date;
+}): Promise<ILinuxIndexFile[]>;
+/**
+ * One APKINDEX block for `recordArg` in the index of `architectureArg`, as
+ * Gitea writes it (`services/packages/alpine/repository.go:215-252`),
+ * including the blank line that ends it. Internal: 1.0.0 exports no
+ * per-entry renderers. The record must have passed `checkRecord`.
+ */
+export declare function renderAlpineIndexEntry(recordArg: IAlpinePackageRecord, architectureArg: string): string;

package/dist_ts/alpine/apkindex.js

@@ -0,0 +1,211 @@
+import * as plugins from '../plugins.js';
+import { isIndexableArchitecture } from '../shared/architecture.js';
+import { LinuxRepoError } from '../shared/errors.js';
+import { assertSegmentName, assertString, assertTimestamp } from '../shared/validation.js';
+import { concatBytes } from '../readers/bytes.js';
+import { writeGoTar } from '../writers/gotar.js';
+/** Gitea's `alpine_module.NoArch`: these packages are listed in every architecture's index too. */
+const NOARCH = 'noarch';
+const INDEX_FILE_NAME = 'APKINDEX';
+const INDEX_ARCHIVE_NAME = 'APKINDEX.tar.gz';
+const INDEX_MODE = 0o600;
+const encoder = new TextEncoder();
+/**
+ * Builds the `APKINDEX.tar.gz` set of one Alpine repository (one branch and
+ * repository) as Gitea 28.2.0 does (`services/packages/alpine/repository.go:150-351`):
+ * one index per architecture the entries name, at
+ * `{branch}/{repository}/{architecture}/APKINDEX.tar.gz`. Every index other
+ * than `noarch` also lists the `noarch` packages, and every block's `A:` is the
+ * index's architecture.
+ *
+ * Each archive is a signature gzip member (a tar entry
+ * `.SIGN.RSA.<signer.keyName>` holding RSA PKCS#1 v1.5 over SHA-1 of the
+ * unsigned stream, without an end-of-archive marker) followed by the unsigned
+ * gzip member (a tar entry `APKINDEX`, mode 0600, with the marker). Tar headers
+ * are byte-for-byte what Go `archive/tar` writes for Gitea (`writeGoTar`); the
+ * signature entry is padded to its 512-byte block (a difference from Gitea),
+ * which Gitea's 4096-bit signatures already fill exactly. Entries are sorted by name, version, architecture and file
+ * name (bytewise), so the bytes depend on the entry set, not its order.
+ *
+ * Pure: the signer is the only call out. `timestamp` is validated but not
+ * written; the format carries no build time. An empty entry set returns `[]`.
+ * Bad input is `invalid-input` and names the entry; an error from the signer
+ * propagates unchanged; a signer result that is not non-empty bytes is
+ * `signing-failed`.
+ */
+export async function buildAlpineIndex(inputArg) {
+    if (inputArg === null || typeof inputArg !== 'object') {
+        throw new LinuxRepoError('invalid-input', 'input must be an object', { field: 'input' });
+    }
+    assertLayoutSegment(inputArg.branch, 'branch');
+    assertLayoutSegment(inputArg.repository, 'repository');
+    assertTimestamp(inputArg.timestamp);
+    const signer = inputArg.signer;
+    if (signer === null || typeof signer !== 'object' || typeof signer.sign !== 'function') {
+        throw new LinuxRepoError('invalid-input', 'signer must be an IAlpineSigner', { field: 'signer' });
+    }
+    assertSegmentName(signer.keyName, 'signer.keyName');
+    if (!Array.isArray(inputArg.entries)) {
+        throw new LinuxRepoError('invalid-input', 'entries must be an array', { field: 'entries' });
+    }
+    const entries = inputArg.entries.map((record, index) => checkRecord(record, `entries[${index}]`));
+    const seen = new Set();
+    for (const record of entries) {
+        const key = `${record.architecture}/${record.fileName}`;
+        if (seen.has(key)) {
+            throw new LinuxRepoError('invalid-input', `duplicate package file ${key}`, { field: 'entries', value: key });
+        }
+        seen.add(key);
+    }
+    entries.sort(compareRecords);
+    const architectures = [...new Set(entries.map((record) => record.architecture))].sort(compareBytes);
+    const files = [];
+    for (const architecture of architectures) {
+        const listed = entries.filter((record) => record.architecture === architecture || (architecture !== NOARCH && record.architecture === NOARCH));
+        const text = listed.map((record) => renderAlpineIndexEntry(record, architecture)).join('');
+        const unsigned = await gzip(writeGoTar([{ name: INDEX_FILE_NAME, mode: INDEX_MODE, data: encoder.encode(text) }], { endOfArchive: true }));
+        const signature = await signer.sign(unsigned);
+        if (!(signature instanceof Uint8Array) || signature.length === 0) {
+            throw new LinuxRepoError('signing-failed', 'the Alpine signer did not return signature bytes', {
+                field: 'signer',
+            });
+        }
+        const signatureMember = await gzip(writeGoTar([{ name: `.SIGN.RSA.${signer.keyName}`, mode: INDEX_MODE, data: signature }], { endOfArchive: false }));
+        const bytes = concatBytes([signatureMember, unsigned]);
+        files.push({
+            path: `${inputArg.branch}/${inputArg.repository}/${architecture}/${INDEX_ARCHIVE_NAME}`,
+            bytes,
+            sha256: plugins.crypto.createHash('sha256').update(bytes).digest('hex'),
+            mediaType: 'application/gzip',
+            stage: 'pointer',
+            aliases: [],
+        });
+    }
+    return files;
+}
+/**
+ * One APKINDEX block for `recordArg` in the index of `architectureArg`, as
+ * Gitea writes it (`services/packages/alpine/repository.go:215-252`),
+ * including the blank line that ends it. Internal: 1.0.0 exports no
+ * per-entry renderers. The record must have passed `checkRecord`.
+ */
+export function renderAlpineIndexEntry(recordArg, architectureArg) {
+    const metadata = recordArg.metadata;
+    const lines = [
+        `C:Q1${Buffer.from(recordArg.digests.controlSha1, 'hex').toString('base64')}`,
+        `P:${recordArg.name}`,
+        `V:${recordArg.version}`,
+        `A:${architectureArg}`,
+    ];
+    if (metadata.description !== '') {
+        lines.push(`T:${metadata.description}`);
+    }
+    if (metadata.projectUrl !== '') {
+        lines.push(`U:${metadata.projectUrl}`);
+    }
+    if (metadata.license !== '') {
+        lines.push(`L:${metadata.license}`);
+    }
+    lines.push(`S:${recordArg.digests.size}`, `I:${metadata.installedSize}`, `o:${metadata.origin}`, `m:${metadata.maintainer}`, `t:${metadata.buildDate}`);
+    if (metadata.commit !== '') {
+        lines.push(`c:${metadata.commit}`);
+    }
+    if (metadata.dependencies.length > 0) {
+        lines.push(`D:${metadata.dependencies.join(' ')}`);
+    }
+    if (metadata.provides.length > 0) {
+        lines.push(`p:${metadata.provides.join(' ')}`);
+    }
+    if (metadata.installIf !== '') {
+        lines.push(`i:${metadata.installIf}`);
+    }
+    if (metadata.providerPriority > 0) {
+        lines.push(`k:${metadata.providerPriority}`);
+    }
+    return `${lines.join('\n')}\n\n`;
+}
+/**
+ * Checks what the index writes. A value with a line break would forge APKINDEX
+ * fields; Gitea's line-based `.PKGINFO` parser never produces one, so refusing
+ * it refuses no package Gitea stored.
+ */
+function checkRecord(recordArg, fieldArg) {
+    const fail = (whatArg) => {
+        throw new LinuxRepoError('invalid-input', `${fieldArg}: ${whatArg}`, { field: fieldArg });
+    };
+    if (recordArg === null || typeof recordArg !== 'object') {
+        return fail('must be an Alpine package record');
+    }
+    const record = recordArg;
+    if (record.format !== 'alpine' || record.metadata === null || typeof record.metadata !== 'object') {
+        return fail('must be an Alpine package record');
+    }
+    if (record.digests === null || typeof record.digests !== 'object') {
+        return fail('digests must be an object');
+    }
+    const text = (valueArg, nameArg, nonEmptyArg = false) => {
+        if (typeof valueArg !== 'string' || /[\n]/.test(valueArg) || (nonEmptyArg && valueArg === '')) {
+            fail(`${nameArg} must be a${nonEmptyArg ? ' non-empty' : ''} string without line breaks`);
+        }
+    };
+    const integer = (valueArg, nameArg, minimumArg = -Number.MAX_SAFE_INTEGER) => {
+        if (typeof valueArg !== 'number' || !Number.isSafeInteger(valueArg) || valueArg < minimumArg) {
+            fail(`${nameArg} must be a safe integer${minimumArg === 0 ? ' >= 0' : ''}`);
+        }
+    };
+    const list = (valueArg, nameArg) => {
+        if (!Array.isArray(valueArg)) {
+            fail(`${nameArg} must be an array`);
+        }
+        valueArg.forEach((item, index) => text(item, `${nameArg}[${index}]`));
+    };
+    text(record.name, 'name', true);
+    text(record.version, 'version', true);
+    assertString(record.fileName, `${fieldArg}.fileName`);
+    if (!isIndexableArchitecture(record.architecture)) {
+        fail(`architecture ${JSON.stringify(record.architecture)} of ${record.fileName} cannot name an index`);
+    }
+    if (typeof record.digests.controlSha1 !== 'string' || !/^[0-9a-f]{40}$/.test(record.digests.controlSha1)) {
+        fail('digests.controlSha1 must be 40 lowercase hex digits');
+    }
+    integer(record.digests.size, 'digests.size', 0);
+    const metadata = record.metadata;
+    for (const key of ['description', 'license', 'projectUrl', 'maintainer', 'origin', 'commit', 'installIf']) {
+        text(metadata[key], `metadata.${key}`);
+    }
+    integer(metadata.installedSize, 'metadata.installedSize');
+    integer(metadata.buildDate, 'metadata.buildDate');
+    integer(metadata.providerPriority, 'metadata.providerPriority');
+    list(metadata.dependencies, 'metadata.dependencies');
+    list(metadata.provides, 'metadata.provides');
+    return record;
+}
+function assertLayoutSegment(valueArg, fieldArg) {
+    assertSegmentName(valueArg, fieldArg);
+    if (valueArg === '.' || valueArg === '..') {
+        throw new LinuxRepoError('invalid-input', `${fieldArg} must not be "." or ".."`, { field: fieldArg });
+    }
+}
+function compareRecords(aArg, bArg) {
+    return (compareBytes(aArg.name, bArg.name) ||
+        compareBytes(aArg.version, bArg.version) ||
+        compareBytes(aArg.architecture, bArg.architecture) ||
+        compareBytes(aArg.fileName, bArg.fileName));
+}
+/** Orders strings by their UTF-8 bytes. */
+function compareBytes(aArg, bArg) {
+    return Buffer.compare(Buffer.from(aArg, 'utf8'), Buffer.from(bArg, 'utf8'));
+}
+function gzip(bytesArg) {
+    return new Promise((resolve, reject) => {
+        plugins.zlib.gzip(bytesArg, (error, result) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(new Uint8Array(result.buffer, result.byteOffset, result.byteLength));
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apkindex.js","sourceRoot":"","sources":["../../ts/alpine/apkindex.ts"],"names":[],"mappings":"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"}

package/dist_ts/alpine/pkginfo.d.ts

@@ -0,0 +1,45 @@
+import type { ILinuxPackageLimits } from '../shared/limits.js';
+/** What Gitea 28.2.0 derives from an apk `.PKGINFO` (`modules/packages/alpine/metadata.go:137-227`). */
+export interface IAlpinePackageInfo {
+    name: string;
+    version: string;
+    architecture: string;
+    description: string;
+    license: string;
+    projectUrl: string;
+    maintainer: string;
+    packager: string;
+    buildDate: number;
+    installedSize: number;
+    origin: string;
+    commit: string;
+    installIf: string;
+    provides: string[];
+    dependencies: string[];
+    providerPriority: number;
+}
+/**
+ * Parses `.PKGINFO` as Gitea's `ParsePackageInfo` does:
+ * - lines split as `bufio.ScanLines` (LF, one trailing CR dropped, a final
+ *   line without LF counts);
+ * - `#` lines and lines without `=` are skipped; key and value are
+ *   `strings.TrimSpace`d around the first `=`; the last value wins, except
+ *   `provides` and `depend`, which collect every non-empty value;
+ * - `builddate`, `size` and `provider_priority` are `strconv.ParseInt(v, 10,
+ *   64)`; a value Go cannot parse (including one outside int64) is ignored,
+ *   so the field keeps its previous value, 0 when there is none
+ *   (`metadata.go:165-174`, `:203-207`);
+ * - an empty `pkgname` or `pkgver` is refused; a `url` Gitea's URL validation
+ *   refuses becomes `''`.
+ *
+ * Bytes are decoded with `decodeGoUtf8`. Where the codec differs from Gitea
+ * (test/test.alpine.reader.node.ts pins each case against Gitea's own code):
+ * - a line is bounded by `maxHeaderBytes` instead of Go's 64 KiB scanner buffer;
+ * - `provides` plus `depend` values are bounded by `maxEntries` instead of 1024;
+ * - invalid UTF-8 becomes U+FFFD per byte, where Gitea 28.2.0 refuses the
+ *   upload because its `encoding/json/v2` cannot store the metadata;
+ * - a number Go parses but JSON cannot hold exactly (beyond
+ *   `Number.MAX_SAFE_INTEGER` in magnitude) is refused as `invalid-field`,
+ *   never rounded.
+ */
+export declare function parseAlpinePackageInfo(bytesArg: Uint8Array, limitsArg: Readonly<ILinuxPackageLimits>): IAlpinePackageInfo;

package/dist_ts/alpine/pkginfo.js

@@ -0,0 +1,159 @@
+import { LinuxRepoError, limitExceeded } from '../shared/errors.js';
+import { goParseInt64, goTrimSpace } from '../shared/gostrings.js';
+import { isValidUrl } from '../shared/url.js';
+import { decodeGoUtf8 } from '../readers/text.js';
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+/**
+ * Parses `.PKGINFO` as Gitea's `ParsePackageInfo` does:
+ * - lines split as `bufio.ScanLines` (LF, one trailing CR dropped, a final
+ *   line without LF counts);
+ * - `#` lines and lines without `=` are skipped; key and value are
+ *   `strings.TrimSpace`d around the first `=`; the last value wins, except
+ *   `provides` and `depend`, which collect every non-empty value;
+ * - `builddate`, `size` and `provider_priority` are `strconv.ParseInt(v, 10,
+ *   64)`; a value Go cannot parse (including one outside int64) is ignored,
+ *   so the field keeps its previous value, 0 when there is none
+ *   (`metadata.go:165-174`, `:203-207`);
+ * - an empty `pkgname` or `pkgver` is refused; a `url` Gitea's URL validation
+ *   refuses becomes `''`.
+ *
+ * Bytes are decoded with `decodeGoUtf8`. Where the codec differs from Gitea
+ * (test/test.alpine.reader.node.ts pins each case against Gitea's own code):
+ * - a line is bounded by `maxHeaderBytes` instead of Go's 64 KiB scanner buffer;
+ * - `provides` plus `depend` values are bounded by `maxEntries` instead of 1024;
+ * - invalid UTF-8 becomes U+FFFD per byte, where Gitea 28.2.0 refuses the
+ *   upload because its `encoding/json/v2` cannot store the metadata;
+ * - a number Go parses but JSON cannot hold exactly (beyond
+ *   `Number.MAX_SAFE_INTEGER` in magnitude) is refused as `invalid-field`,
+ *   never rounded.
+ */
+export function parseAlpinePackageInfo(bytesArg, limitsArg) {
+    const info = {
+        name: '',
+        version: '',
+        architecture: '',
+        description: '',
+        license: '',
+        projectUrl: '',
+        maintainer: '',
+        packager: '',
+        buildDate: 0,
+        installedSize: 0,
+        origin: '',
+        commit: '',
+        installIf: '',
+        provides: [],
+        dependencies: [],
+        providerPriority: 0,
+    };
+    for (const line of scanLines(bytesArg, limitsArg.maxHeaderBytes)) {
+        if (line.startsWith('#')) {
+            continue;
+        }
+        const equals = line.indexOf('=');
+        if (equals < 0) {
+            continue;
+        }
+        const key = goTrimSpace(line.slice(0, equals));
+        const value = goTrimSpace(line.slice(equals + 1));
+        switch (key) {
+            case 'pkgname':
+                info.name = value;
+                break;
+            case 'pkgver':
+                info.version = value;
+                break;
+            case 'pkgdesc':
+                info.description = value;
+                break;
+            case 'url':
+                info.projectUrl = value;
+                break;
+            case 'builddate':
+                info.buildDate = goParseInt(value, key) ?? info.buildDate;
+                break;
+            case 'size':
+                info.installedSize = goParseInt(value, key) ?? info.installedSize;
+                break;
+            case 'arch':
+                info.architecture = value;
+                break;
+            case 'origin':
+                info.origin = value;
+                break;
+            case 'commit':
+                info.commit = value;
+                break;
+            case 'maintainer':
+                info.maintainer = value;
+                break;
+            case 'packager':
+                info.packager = value;
+                break;
+            case 'license':
+                info.license = value;
+                break;
+            case 'install_if':
+                info.installIf = value;
+                break;
+            case 'provides':
+            case 'depend':
+                if (value !== '') {
+                    if (info.provides.length + info.dependencies.length >= limitsArg.maxEntries) {
+                        throw limitExceeded('maxEntries', limitsArg.maxEntries, '.PKGINFO provides and depend values');
+                    }
+                    (key === 'provides' ? info.provides : info.dependencies).push(value);
+                }
+                break;
+            case 'provider_priority':
+                info.providerPriority = goParseInt(value, key) ?? info.providerPriority;
+                break;
+        }
+    }
+    if (info.name === '') {
+        throw new LinuxRepoError('missing-field', '.PKGINFO has no pkgname', { field: 'pkgname' });
+    }
+    if (info.version === '') {
+        throw new LinuxRepoError('missing-field', '.PKGINFO has no pkgver', { field: 'pkgver' });
+    }
+    if (!isValidUrl(info.projectUrl)) {
+        info.projectUrl = '';
+    }
+    return info;
+}
+/** `bufio.ScanLines` over the bytes, each line decoded as Gitea stores it. */
+function* scanLines(bytesArg, maxLineBytesArg) {
+    let start = 0;
+    while (start < bytesArg.length) {
+        const newline = bytesArg.indexOf(0x0a, start);
+        const end = newline < 0 ? bytesArg.length : newline;
+        let lineEnd = end;
+        if (lineEnd > start && bytesArg[lineEnd - 1] === 0x0d) {
+            lineEnd -= 1;
+        }
+        if (lineEnd - start > maxLineBytesArg) {
+            throw limitExceeded('maxHeaderBytes', maxLineBytesArg, '.PKGINFO line');
+        }
+        yield decodeGoUtf8(bytesArg.subarray(start, lineEnd));
+        start = newline < 0 ? bytesArg.length : newline + 1;
+    }
+}
+/**
+ * Go `strconv.ParseInt(value, 10, 64)`: `null` where Go returns an error (Gitea
+ * then keeps the previous value); `invalid-field` for an int64 beyond the safe
+ * JSON integer range.
+ */
+function goParseInt(valueArg, fieldArg) {
+    const value = goParseInt64(valueArg);
+    if (value === null) {
+        return null;
+    }
+    if (value > MAX_SAFE || value < -MAX_SAFE) {
+        throw new LinuxRepoError('invalid-field', `.PKGINFO ${fieldArg} is beyond the safe integer range`, {
+            field: fieldArg,
+            value: valueArg,
+        });
+    }
+    return Number(value) + 0;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/alpine/reader.d.ts

@@ -0,0 +1,20 @@
+import { type ILinuxPackageLimits } from '../shared/limits.js';
+import type { IAlpinePackageRecord } from '../shared/types.js';
+/**
+ * Reads an apk v2 package (concatenated gzip members: usually the signature,
+ * the control segment holding `.PKGINFO`, and the data) into a record, as
+ * Gitea 28.2.0's `ParsePackage` does (`modules/packages/alpine/metadata.go:77-134`):
+ * - gzip members are read one at a time; the first member whose tar holds an
+ *   entry named exactly `.PKGINFO` is the control segment. Unsigned packages
+ *   (no signature member) are accepted;
+ * - `digests.controlSha1` is the SHA-1 of exactly that member's bytes (the
+ *   APKINDEX `C:` value is `Q1` plus its base64);
+ * - the rest of the input is hashed, never decompressed;
+ * - the record's `fileName` is Gitea's `{name}-{version}.apk`.
+ *
+ * Each member read before the control segment is buffered and bounded by
+ * `maxMetadataBytes` (member bytes) and `maxDecompressedMetadataBytes` (its
+ * tar). An apk v3 (ADB) package is `unsupported-package-format`, as Gitea
+ * refuses it too. On failure the reader stops pulling and returns no record.
+ */
+export declare function readAlpinePackage(sourceArg: AsyncIterable<Uint8Array>, limitsArg?: Partial<ILinuxPackageLimits>): Promise<IAlpinePackageRecord>;