@foss.global/codefeed 5.3.0 → 5.5.0

package/dist_ts/giteasourceinventory.packages.js

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import * as validation from './forgeinventory.validation.js';
+import { swiftManifestKey } from './giteasourcetransfer.documents.js';
 /** Media types Gitea serves an index or a manifest list as; an index candidate must be one of them. */
 export const containerIndexMediaTypes = Object.freeze([
     'application/vnd.oci.image.index.v1+json',
@@ -50,6 +51,184 @@ export const swiftPackageParts = (nameArg) => {
         throw new validation.ForgeInventoryError('invalid-swift-name');
     return { scope: match[1], name: match[2] };
 };
+/**
+ * A Swift release's `Package.swift`, or with `swiftVersionArg` its alternate
+ * manifest, read with `clientArg`'s `token` authorization; null when Gitea
+ * redirects the alternate one to the release's own `Package.swift` (303),
+ * which is how it answers a version it holds no manifest for. No redirect is
+ * followed: any other redirect rejects with `swift-manifest-redirect-unexpected`,
+ * a redirect of `Package.swift` itself with `http-<status>`, and a body that
+ * is not `text/x-swift` with `invalid-content-type`. The read counts no
+ * download.
+ */
+export const readSwiftManifest = async (clientArg, baseUrlArg, ownerArg, partsArg, versionArg, swiftVersionArg, signalArg) => {
+    const url = new URL(`${baseUrlArg}/api/packages/${encodeURIComponent(ownerArg)}/swift/${encodeURIComponent(partsArg.scope)}/${encodeURIComponent(partsArg.name)}/${encodeURIComponent(versionArg)}/Package.swift`);
+    if (swiftVersionArg !== null)
+        url.searchParams.set('swift-version', swiftVersionArg);
+    const response = await clientArg.requestBytesOrRedirect(url, { accept: 'application/vnd.swift.registry.v1+swift', signal: signalArg });
+    if (response.kind === 'redirect') {
+        if (swiftVersionArg === null)
+            throw new validation.ForgeInventoryError(`http-${response.status}`);
+        // Gitea's answer for a missing alternate manifest: 303 to the release's
+        // `Package.swift` under its configured root, with the owner lowercased
+        // and scope, name and version as the request named them.
+        const expected = new URL(`${baseUrlArg}/api/packages/${ownerArg.toLowerCase()}/swift/${partsArg.scope}/${partsArg.name}/${versionArg}/Package.swift`);
+        let location = null;
+        try {
+            location = response.location === null ? null : new URL(response.location, url);
+        }
+        catch {
+            location = null;
+        }
+        if (response.status !== 303 || location === null || location.href !== expected.href) {
+            throw new validation.ForgeInventoryError('swift-manifest-redirect-unexpected');
+        }
+        return null;
+    }
+    if (response.mediaType !== 'text/x-swift')
+        throw new validation.ForgeInventoryError('invalid-content-type');
+    return { bytes: response.bytes, mediaType: 'text/x-swift' };
+};
+/** Distinct manifest keys read per Swift version, `''` included; Gitea keeps at most 64 manifests (`maxManifestFiles`). */
+const maxSwiftManifestCandidates = 64;
+/**
+ * The name of every central-directory entry of a zip archive, in directory
+ * order, each byte one code unit (Go strings are bytes, and only ASCII names
+ * can match `manifestPattern`). It reads the directory as Go 1.27.2's
+ * `archive/zip` `NewReader` does, the archive/zip Gitea 28.2.0 builds with:
+ * - the end record is the last signature in the final 65 KiB whose comment
+ *   fits in the archive;
+ * - its zip64 locator and end record are used when a count, size or offset
+ *   is saturated and a locator for disk 0 of 1 sits right before it;
+ * - the base offset of data prepended to the archive is the end record's
+ *   position minus the directory's size and offset, unless a directory
+ *   header sits at the unadjusted offset;
+ * - headers are read one after another until one is malformed or cut off
+ *   (a zip64 field too short for the saturated sizes and offset it stands
+ *   for is malformed), and their count must agree with the end record's in
+ *   its low 16 bits.
+ * Anything Go refuses rejects with `swift-archive-invalid`.
+ */
+export const zipEntryNames = (archiveArg) => {
+    const invalid = () => new validation.ForgeInventoryError('swift-archive-invalid');
+    const size = archiveArg.byteLength;
+    const sizeBig = BigInt(size);
+    let endOffset = -1;
+    for (let index = size - 22; index >= Math.max(0, size - 65 * 1024); index--) {
+        if (archiveArg.readUInt32LE(index) === 0x06054b50) {
+            endOffset = index;
+            break;
+        }
+    }
+    if (endOffset < 0 || endOffset + 22 + archiveArg.readUInt16LE(endOffset + 20) > size)
+        throw invalid();
+    let directoryEnd = BigInt(endOffset);
+    let records = BigInt(archiveArg.readUInt16LE(endOffset + 10));
+    let directorySize = BigInt(archiveArg.readUInt32LE(endOffset + 12));
+    let directoryOffset = BigInt(archiveArg.readUInt32LE(endOffset + 16));
+    if (records === 0xffffn || directorySize === 0xffffffffn || directoryOffset === 0xffffffffn) {
+        const locator = endOffset - 20;
+        if (locator >= 0 && archiveArg.readUInt32LE(locator) === 0x07064b50 && archiveArg.readUInt32LE(locator + 4) === 0
+            && archiveArg.readUInt32LE(locator + 16) === 1) {
+            // Go reads the offset as an int64: one past its range is negative and leaves the archive as zip32.
+            const record = archiveArg.readBigInt64LE(locator + 8);
+            if (record >= 0n) {
+                if (record + 56n > sizeBig || archiveArg.readUInt32LE(Number(record)) !== 0x06064b50)
+                    throw invalid();
+                directoryEnd = record;
+                records = archiveArg.readBigUInt64LE(Number(record) + 32);
+                directorySize = archiveArg.readBigUInt64LE(Number(record) + 40);
+                directoryOffset = archiveArg.readBigUInt64LE(Number(record) + 48);
+            }
+        }
+    }
+    if (directorySize > 0x7fffffffffffffffn || directoryOffset > 0x7fffffffffffffffn)
+        throw invalid();
+    let baseOffset = directoryEnd - directorySize - directoryOffset;
+    if (baseOffset + directoryOffset < 0n || baseOffset + directoryOffset >= sizeBig)
+        throw invalid();
+    if (baseOffset > 0n && directoryHeader(archiveArg, Number(directoryOffset)).kind === 'entry')
+        baseOffset = 0n;
+    const names = [];
+    let offset = Number(baseOffset + directoryOffset);
+    while (true) {
+        const header = directoryHeader(archiveArg, offset);
+        if (header.kind === 'end')
+            break;
+        // Go's `io.ReadFull` reports a read that gets no byte at all as `io.EOF`, which fails the archive.
+        if (header.kind === 'eof')
+            throw invalid();
+        names.push(header.name);
+        offset = header.next;
+    }
+    if ((BigInt(names.length) & 0xffffn) !== (records & 0xffffn))
+        throw invalid();
+    return names;
+};
+/**
+ * The central-directory header at `offsetArg`, as Go 1.27.2's
+ * `readDirectoryHeader` reads it: `entry` with its name and the offset of the
+ * next header; `end` where Go stops reading headers (a header cut off by the
+ * archive's end, another signature, or a zip64 field shorter than 8 bytes for
+ * each saturated size and offset); `eof` where a read gets no byte at all.
+ */
+const directoryHeader = (archiveArg, offsetArg) => {
+    const available = archiveArg.byteLength - offsetArg;
+    if (available <= 0)
+        return { kind: 'eof' };
+    if (available < 46)
+        return { kind: 'end' };
+    if (archiveArg.readUInt32LE(offsetArg) !== 0x02014b50)
+        return { kind: 'end' };
+    const nameLength = archiveArg.readUInt16LE(offsetArg + 28);
+    const extraLength = archiveArg.readUInt16LE(offsetArg + 30);
+    const commentLength = archiveArg.readUInt16LE(offsetArg + 32);
+    const variable = nameLength + extraLength + commentLength;
+    if (variable > 0 && available === 46)
+        return { kind: 'eof' };
+    if (available - 46 < variable)
+        return { kind: 'end' };
+    const saturated = [20, 24, 42].filter((fieldArg) => archiveArg.readUInt32LE(offsetArg + fieldArg) === 0xffffffff).length;
+    let extra = offsetArg + 46 + nameLength;
+    const extraEnd = extra + extraLength;
+    while (extraEnd - extra >= 4) {
+        const tag = archiveArg.readUInt16LE(extra);
+        const fieldSize = archiveArg.readUInt16LE(extra + 2);
+        extra += 4;
+        if (extraEnd - extra < fieldSize)
+            break;
+        // The zip64 field holds 8 bytes for each saturated field, in order.
+        if (tag === 0x0001 && fieldSize < 8 * saturated)
+            return { kind: 'end' };
+        extra += fieldSize;
+    }
+    return { kind: 'entry', name: archiveArg.toString('latin1', offsetArg + 46, offsetArg + 46 + nameLength), next: offsetArg + 46 + variable };
+};
+/**
+ * The keys of the manifests Gitea 28.2.0 may hold for a Swift source
+ * archive, sorted in code-unit order: `''`, and the key of every
+ * central-directory entry, in any directory, whose name does not end in `/`
+ * and whose base name matches Gitea's `manifestPattern` and parses
+ * (`swiftManifestKey`). Gitea keeps only the manifests of the shallowest
+ * directory, so the keys are a superset of what it holds, and its answer for
+ * each key decides. More than `maxSwiftManifestCandidates` distinct keys
+ * reject with `swift-manifest-candidates-over-bound`; an archive Go's
+ * `archive/zip` refuses with `swift-archive-invalid`.
+ */
+export const swiftManifestCandidates = (archiveArg) => {
+    const keys = new Set(['']);
+    for (const name of zipEntryNames(archiveArg)) {
+        if (name.endsWith('/'))
+            continue;
+        const key = swiftManifestKey(name.slice(name.lastIndexOf('/') + 1));
+        if (key === null)
+            continue;
+        keys.add(key);
+        if (keys.size > maxSwiftManifestCandidates)
+            throw new validation.ForgeInventoryError('swift-manifest-candidates-over-bound');
+    }
+    return [...keys].sort(compareText);
+};
 /**
  * The digest of the manifest a container version holds: `sha256:` and the
  * SHA-256 of the blob holding the version's `manifest.json`; null for a
@@ -136,4 +315,4 @@ export const composeGiteaPackageContent = (discoveredArg, packagesArg) => {
         owners: owners.map((ownerArg) => ({ owner: ownerArg, ...group(refs.filter((refArg) => refArg.owner === ownerArg), records) })),
     };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"giteasourceinventory.packages.js","sourceRoot":"","sources":["../ts/giteasourceinventory.packages.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"giteasourceinventory.packages.js","sourceRoot":"","sources":["../ts/giteasourceinventory.packages.ts"],"names":[],"mappings":"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"}

package/dist_ts/giteasourcetransfer.documents.d.ts

@@ -28,8 +28,23 @@ export interface IGiteaCanonicalPackageDocument {
  */
 export declare const canonicalPackageDocument: (kindArg: TGiteaCanonicalPackageDocumentKind, bytesArg: Uint8Array) => IGiteaCanonicalPackageDocument;
 /**
- * A Swift version as Gitea keys an alternate manifest (`Package@swift-<v>.swift`),
- * trimmed by its `TrimmedVersionString`: major and minor, and the patch only
- * when it is not zero.
+ * Whether `valueArg` is a Swift version Gitea 28.2.0 can key an alternate
+ * manifest (`Package@swift-<v>.swift`) by. Gitea parses the file name's
+ * version with go-version's `NewSemver`, refuses an archive whose version
+ * does not parse (`ErrInvalidManifestVersion`), and keys the manifest by
+ * `TrimmedVersionString`: major and minor, and the patch only when it is not
+ * zero, each in decimal without leading zeros (`modules/packages/swift/metadata.go`).
+ * So a key has two or three segments, no leading zeros, no zero patch, and
+ * every segment at most 9223372036854775807, compared by value.
  */
-export declare const swiftManifestVersionPattern: RegExp;
+export declare const isSwiftManifestVersion: (valueArg: unknown) => valueArg is string;
+/**
+ * The key Gitea 28.2.0 would hold a manifest with base name `baseNameArg`
+ * by: `''` for `Package.swift`; for `Package@swift-<v>.swift`, `<v>` parsed
+ * as go-version's `NewSemver` parses it (leading zeros allowed, every segment
+ * a signed 64-bit integer, missing segments zero) and written as
+ * `TrimmedVersionString` writes it, a key `isSwiftManifestVersion` accepts.
+ * Null when the name is not a manifest name, or when a segment is over int64,
+ * which `NewSemver` refuses, so Gitea can never hold the key.
+ */
+export declare const swiftManifestKey: (baseNameArg: string) => string | null;

package/dist_ts/giteasourcetransfer.documents.js

@@ -78,9 +78,53 @@ export const canonicalPackageDocument = (kindArg, bytesArg) => {
     return { bytes, sha256: plugins.crypto.createHash('sha256').update(bytes).digest('hex') };
 };
 /**
- * A Swift version as Gitea keys an alternate manifest (`Package@swift-<v>.swift`),
- * trimmed by its `TrimmedVersionString`: major and minor, and the patch only
- * when it is not zero.
+ * The largest segment Gitea's version parser reads: hashicorp/go-version
+ * (v1.9.0 in Gitea 28.2.0) parses every segment as a signed 64-bit integer
+ * and refuses a larger one.
  */
-export const swiftManifestVersionPattern = /^(?:0|[1-9]\d{0,17})\.(?:0|[1-9]\d{0,17})(?:\.[1-9]\d{0,17})?$/;
-//# sourceMappingURL=data:application/json;base64,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
+const maxSwiftVersionSegment = 9223372036854775807n;
+/** Major and minor, and an optional patch, in decimal without leading zeros. */
+const trimmedSwiftVersionShape = /^(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\.([1-9]\d*))?$/;
+/**
+ * Whether `valueArg` is a Swift version Gitea 28.2.0 can key an alternate
+ * manifest (`Package@swift-<v>.swift`) by. Gitea parses the file name's
+ * version with go-version's `NewSemver`, refuses an archive whose version
+ * does not parse (`ErrInvalidManifestVersion`), and keys the manifest by
+ * `TrimmedVersionString`: major and minor, and the patch only when it is not
+ * zero, each in decimal without leading zeros (`modules/packages/swift/metadata.go`).
+ * So a key has two or three segments, no leading zeros, no zero patch, and
+ * every segment at most 9223372036854775807, compared by value.
+ */
+export const isSwiftManifestVersion = (valueArg) => {
+    if (typeof valueArg !== 'string')
+        return false;
+    const match = trimmedSwiftVersionShape.exec(valueArg);
+    if (!match)
+        return false;
+    return match.slice(1).every((segmentArg) => segmentArg === undefined || BigInt(segmentArg) <= maxSwiftVersionSegment);
+};
+/** Gitea 28.2.0's `manifestPattern` (`modules/packages/swift/metadata.go:27`), matched against a file's base name. */
+const swiftManifestNamePattern = /^Package(?:@swift-(\d+(?:\.\d+)?(?:\.\d+)?))?\.swift$/;
+/**
+ * The key Gitea 28.2.0 would hold a manifest with base name `baseNameArg`
+ * by: `''` for `Package.swift`; for `Package@swift-<v>.swift`, `<v>` parsed
+ * as go-version's `NewSemver` parses it (leading zeros allowed, every segment
+ * a signed 64-bit integer, missing segments zero) and written as
+ * `TrimmedVersionString` writes it, a key `isSwiftManifestVersion` accepts.
+ * Null when the name is not a manifest name, or when a segment is over int64,
+ * which `NewSemver` refuses, so Gitea can never hold the key.
+ */
+export const swiftManifestKey = (baseNameArg) => {
+    const match = swiftManifestNamePattern.exec(baseNameArg);
+    if (!match)
+        return null;
+    if (match[1] === undefined)
+        return '';
+    const segments = match[1].split('.').map((segmentArg) => BigInt(segmentArg));
+    if (segments.some((segmentArg) => segmentArg > maxSwiftVersionSegment))
+        return null;
+    const [major, minor = 0n, patch = 0n] = segments;
+    const key = patch === 0n ? `${major}.${minor}` : `${major}.${minor}.${patch}`;
+    return isSwiftManifestVersion(key) ? key : null;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2l0ZWFzb3VyY2V0cmFuc2Zlci5kb2N1bWVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9naXRlYXNvdXJjZXRyYW5zZmVyLmRvY3VtZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEtBQUssVUFBVSxNQUFNLGdDQUFnQyxDQUFDO0FBaUI3RDs7OztHQUlHO0FBQ0gsTUFBTSxtQkFBbUIsR0FBd0UsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUM3RyxhQUFhLEVBQUUsWUFBWTtJQUMzQixlQUFlLEVBQUUsSUFBSTtJQUNyQixtQkFBbUIsRUFBRSxRQUFRO0lBQzdCLG1CQUFtQixFQUFFLElBQUk7Q0FDMUIsQ0FBQyxDQUFDO0FBRUg7OztHQUdHO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRyxDQUFDLE9BQWUsRUFBRSxRQUFnQixFQUFVLEVBQUU7SUFDdEUsSUFBSSxJQUFJLEdBQUcsQ0FBQyxDQUFDO0lBQ2IsSUFBSSxLQUFLLEdBQUcsQ0FBQyxDQUFDO0lBQ2QsT0FBTyxJQUFJLEdBQUcsT0FBTyxDQUFDLE1BQU0sSUFBSSxLQUFLLEdBQUcsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ3hELE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFFLENBQUM7UUFDN0MsTUFBTSxVQUFVLEdBQUcsUUFBUSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUUsQ0FBQztRQUNoRCxJQUFJLFNBQVMsS0FBSyxVQUFVO1lBQUUsT0FBTyxTQUFTLEdBQUcsVUFBVSxDQUFDO1FBQzVELElBQUksSUFBSSxTQUFTLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNuQyxLQUFLLElBQUksVUFBVSxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUNELE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUMsQ0FBQztBQUM3RCxDQUFDLENBQUM7QUFFRiwySEFBMkg7QUFDM0gsTUFBTSxhQUFhLEdBQUcsQ0FBQyxRQUFpQixFQUFVLEVBQUU7SUFDbEQsSUFBSSxRQUFRLEtBQUssSUFBSSxJQUFJLE9BQU8sUUFBUSxLQUFLLFNBQVMsSUFBSSxPQUFPLFFBQVEsS0FBSyxRQUFRO1FBQUUsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3hILElBQUksT0FBTyxRQUFRLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDakMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDO1lBQUUsTUFBTSxJQUFJLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO1FBQ3hHLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBQ0QsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQztRQUFFLE9BQU8sSUFBSSxRQUFRLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDO0lBQ2pGLE1BQU0sTUFBTSxHQUFHLFFBQW1DLENBQUM7SUFDbkQsT0FBTyxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLElBQUksYUFBYSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQztBQUNwSixDQUFDLENBQUM7QUFFRjs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLENBQUMsT0FBMkMsRUFBRSxRQUFvQixFQUFrQyxFQUFFO0lBQzVJLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLG1CQUFtQixFQUFFLE9BQU8sQ0FBQztRQUFFLE1BQU0sSUFBSSxVQUFVLENBQUMsbUJBQW1CLENBQUMsK0JBQStCLENBQUMsQ0FBQztJQUM1SCxJQUFJLFNBQWlCLENBQUM7SUFDdEIsSUFBSSxDQUFDO1FBQ0gsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLFdBQVcsQ0FBQyxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQVksQ0FBQztRQUNqRyxJQUFJLE1BQU0sS0FBSyxJQUFJLElBQUksT0FBTyxNQUFNLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDO1lBQUUsTUFBTSxJQUFJLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO1FBQy9JLE1BQU0sTUFBTSxHQUFHLG1CQUFtQixDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzVDLElBQUksTUFBTSxLQUFLLElBQUk7WUFBRSxPQUFRLE1BQWtDLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDeEUsU0FBUyxHQUFHLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQ1AsMkZBQTJGO1FBQzNGLE1BQU0sSUFBSSxVQUFVLENBQUMsbUJBQW1CLENBQUMsd0JBQXdCLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBQ0QsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDN0MsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO0FBQzVGLENBQUMsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCxNQUFNLHNCQUFzQixHQUFHLG9CQUFvQixDQUFDO0FBRXBELGdGQUFnRjtBQUNoRixNQUFNLHdCQUF3QixHQUFHLCtDQUErQyxDQUFDO0FBRWpGOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLENBQUMsUUFBaUIsRUFBc0IsRUFBRTtJQUM5RSxJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVE7UUFBRSxPQUFPLEtBQUssQ0FBQztJQUMvQyxNQUFNLEtBQUssR0FBRyx3QkFBd0IsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDdEQsSUFBSSxDQUFDLEtBQUs7UUFBRSxPQUFPLEtBQUssQ0FBQztJQUN6QixPQUFPLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxVQUFVLEtBQUssU0FBUyxJQUFJLE1BQU0sQ0FBQyxVQUFVLENBQUMsSUFBSSxzQkFBc0IsQ0FBQyxDQUFDO0FBQ3hILENBQUMsQ0FBQztBQUVGLHNIQUFzSDtBQUN0SCxNQUFNLHdCQUF3QixHQUFHLHVEQUF1RCxDQUFDO0FBRXpGOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsQ0FBQyxXQUFtQixFQUFpQixFQUFFO0lBQ3JFLE1BQU0sS0FBSyxHQUFHLHdCQUF3QixDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUN6RCxJQUFJLENBQUMsS0FBSztRQUFFLE9BQU8sSUFBSSxDQUFDO0lBQ3hCLElBQUksS0FBSyxDQUFDLENBQUMsQ0FBQyxLQUFLLFNBQVM7UUFBRSxPQUFPLEVBQUUsQ0FBQztJQUN0QyxNQUFNLFFBQVEsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7SUFDN0UsSUFBSSxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxVQUFVLEdBQUcsc0JBQXNCLENBQUM7UUFBRSxPQUFPLElBQUksQ0FBQztJQUNwRixNQUFNLENBQUMsS0FBSyxFQUFFLEtBQUssR0FBRyxFQUFFLEVBQUUsS0FBSyxHQUFHLEVBQUUsQ0FBQyxHQUFHLFFBQVEsQ0FBQztJQUNqRCxNQUFNLEdBQUcsR0FBRyxLQUFLLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLEtBQUssSUFBSSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxLQUFLLElBQUksS0FBSyxJQUFJLEtBQUssRUFBRSxDQUFDO0lBQzlFLE9BQU8sc0JBQXNCLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ2xELENBQUMsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foss.global/codefeed",
-  "version": "5.3.0",
+  "version": "5.5.0",
   "private": false,
   "description": "The @foss.global/codefeed module generates commit/activity feeds from forge providers including Gitea and GitManager.",
   "exports": {
@@ -11,14 +11,14 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@foss.global/forgefixtures": "^1.0.0",
-    "@git.zone/tsrepo": "^2.1.0",
+    "@foss.global/forgefixtures": "^1.2.0",
+    "@git.zone/tsrepo": "^2.2.0",
     "@push.rocks/qenv": "^8.2.1",
     "@types/node": "^26.6.6"
   },
   "dependencies": {
     "@foss.global/gitmanager": "^2.4.0",
-    "@foss.global/interfaces": "^3.2.1",
+    "@foss.global/interfaces": "^3.5.1",
     "@push.rocks/lik": "^6.4.4",
     "@push.rocks/smartnpm": "^2.1.3",
     "@push.rocks/smarttime": "^5.0.1"

package/readme.md

@@ -101,13 +101,13 @@ const results = await reader.measureUnits(reader.units(discovery), {
 const inventory = composeGiteaSourceInventory(discovery, results, [{ package: '@foss.global/codefeed', version }]);
 ```
 
-A run is split into units: the instance, each owner and each repository. `measureUnit` never rejects; a unit whose primary record cannot be read becomes `failed` with a sanitized reason. A resumed run measures failed units, and units holding a partial measure, again and passes all results to `composeGiteaSourceInventory`, where the last result per unit wins. The composed document is deterministic: it carries no timestamps, sorts owners, repositories, packages and reasons, and does not depend on the order of the results. An aborted signal or a rejected `onResult` aborts the units in flight, hands over no further result, and rejects `measureUnits` once every worker has stopped.
+A run is split into units: the instance, each owner and each repository, and, when discovery selects them, each package and each repository's collaboration. `measureUnit` never rejects; a unit whose primary record cannot be read becomes `failed` with a sanitized reason. A resumed run measures failed units, and units holding a partial measure, again and passes all results to `composeGiteaSourceInventory`, where the last result per unit wins. The composed document is deterministic: it carries no timestamps, sorts owners, repositories, packages and reasons, and does not depend on the order of the results. An aborted signal or a rejected `onResult` aborts the units in flight, hands over no further result, and rejects `measureUnits` once every worker has stopped.
 
 Discovery records each repository's Gitea `id` as a canonical decimal string, and `units()` passes it into the repository unit. A unit with an `id` fails with `repository-identity-changed` when its name answers with another id, as after a rename and a new repository under the old name; a unit without one, from a discovery stored by an earlier version, is checked by name only. `composeGiteaSourceInventory` counts a repository result for another id than discovery recorded as a failed unit (`repository: unit failed: repository-identity-changed`), and adds `repository: duplicate-id` when two measured repositories share one id, which a discovery without ids cannot rule out.
 
 `lookupRepository(id)` reads one repository by its id through `GET /api/v1/repositories/{id}`, which keeps answering after a rename or transfer. It resolves `{ status: 'present', id, owner, name }` with the name Gitea gives the repository now, or `{ status: 'absent', id }` only when Gitea answers 404, which a site administrator gets only for a deleted repository. Every other failed read rejects with its code, so a timeout or a 500 never counts as a deletion; an id that is not a canonical decimal rejects with `invalid-repository-id` without a request.
 
-What is measured: users with their account flags, two-factor and SSH/GPG keys; organizations, members, teams, team memberships and repository grants; repositories with their flags, Git refs split into branches, tags, pull request refs and other refs, Git objects and their uncompressed bytes, LFS objects referenced anywhere in history with the bytes Gitea holds and the number it lacks, issues, pull requests, comments, reviews, review comments, labels, milestones, reactions and attachments; releases including drafts, assets and asset bytes; wiki pages; collaborators, team grants, SSH deploy keys, deploy tokens, webhooks, branch and tag protections and push mirrors; packages per type with versions, files and bytes; system webhooks, Actions runners, workflows, runs, artifacts and the number of Actions secrets and variables; unadopted repositories.
+What is measured: users with their account flags, two-factor and SSH/GPG keys; organizations, members, teams, team memberships and repository grants; repositories with their flags, Git refs split into branches, tags, pull request refs and other refs, Git objects and their uncompressed bytes, LFS objects referenced anywhere in history with the bytes Gitea holds and the number it lacks, issues, pull requests, comments, reviews, review comments, labels, milestones, reactions and attachments, with comments, reactions and attachments also split by kind (`collaboration.byKind`) and pull requests counted as open, closed and merged; project boards per repository and per owner; releases including drafts, assets and asset bytes; wiki pages; collaborators, team grants, SSH deploy keys, deploy tokens, webhooks, branch and tag protections and push mirrors; packages per type with versions, files and bytes; system webhooks, Actions runners, workflows, runs, artifacts and the number of Actions secrets and variables; unadopted repositories.
 
 Beyond counts, each repository keeps records of what the migration recreates. `description` is the repository's description exactly as Gitea's API reports it, without trimming or normalising; `''` means the source has none. A description that is not a string fails the repository unit with `invalid-string`, so the inventory stays incomplete; reports from readers before 4.4.0 carry no `description`, which a consumer treats as unread, never as `''`. `releaseRecords` lists every release, drafts and prereleases included, sorted by numeric id, as `TForgeSourceRelease` records (narrow on `draft` before reading `publishedAt` as a string): tag name, target commitish, name, body, the draft and prerelease flags, created and published times as Gitea reports them (a published release must carry a valid publication time; a draft's is recorded as reported, `null` on Gitea 28 and never replaced by its creation time, and a draft's tag does not exist as a Git ref yet; on Gitea 28 a new release's creation time is the date of the commit it points at), an author snapshot (account id and login; Gitea's placeholder for a deleted account has id `-1`) and its assets sorted by numeric id with id, storage `uuid`, name, size, download count and creation time. Gitea exposes no content digest, so a record carries none; a replaced file carries another id and uuid, and the download count moves with every download, so it never decides whether a release changed. `protections` holds the branch protection rules sorted by rule name (code-unit order) with every restriction Gitea reads back, allowlists included, and the tag protection rules sorted by numeric id with their name pattern and allowlist. `releaseRecords` is null while a release count is not complete, and `protections` is null while either protection count is not; the counts then say why.
 
@@ -124,9 +124,33 @@ Secrets are counted, never named: the report carries no tokens, Actions secret o
 Git-level measures come from a mirror clone of every ref Gitea advertises, `refs/pull/*` included, made with `@foss.global/gitmanager` in a fresh directory below `gitWorkDir` and removed afterwards. The reader's login and token form Basic credentials; the credential reaches Git only through GIT_CONFIG_* entries in the child process environment; it is never in the URL, the command line or any file. The private CA list applies to the clone as well. The mirror's HEAD becomes the repository's `head`: the ref it names as `target` and whether it `resolves`. In a repository that is not `empty`, a HEAD that does not resolve names a missing branch, such as a default branch deleted at the source, and a `target` other than `refs/heads/<defaultBranch>` means Gitea's setting and its Git HEAD disagree. `head` is null when the mirror or its refs could not be read. A detached source HEAD is one such case: GitManager's mirror import requires a symbolic HEAD, so the clone fails with `git-mirror-failed`, and this reader never reports a `target` of null. The same mirror records `refDigests`: for each of `refs/heads/`, `refs/tags/` and `refs/notes/`, GitManager's ref `inventoryDigest` (HEAD and the refs under that prefix) and the `refCount` of that selection, read as one single-ref `listRefs` page per prefix; codefeed computes no digest of its own. Any other GitManager repository with the same HEAD and refs under a prefix reports the same digest, so a migration compares them with its native copy. Pull request refs have no digest, and `git.otherRefs - refDigests.notes.refCount` refs lie outside every digested namespace. `refDigests` is null whenever `head` is, or when any of the three reads fails; it is never partial. The mirror's distinct LFS pointers, from every reachable revision, are checked against Gitea in batches of 100: an object with a download action counts as held, one answered with error 404 as missing, and any other answer makes the LFS measures `partial`. A clone that fails or exceeds `gitTimeoutMs` makes every Git and LFS measure of that repository `partial`; only the API-reported size stays complete. A clone starts only once its scratch reservation, twice the reported size plus 64 MiB, fits the free space of the file system that holds `gitWorkDir`, counting the reservations of the clones already in flight from every reader in the process. A clone that does not fit waits for them, in arrival order; one that does not fit even alone makes every Git and LFS measure of its repository `partial` with `git-workdir-too-small`, so the inventory stays incomplete. Size `gitWorkDir` for the largest repositories measured at once.
 
 Known gaps that keep an inventory incomplete:
-- A repository with its issues or pull requests unit disabled hides both through the API, so its issues, pull requests, comments, reviews, reactions and attachments are `notMeasured`. A disabled wiki hides its pages the same way. Labels, milestones, releases and Actions stay readable while their units are disabled.
+- Gitea's issue and repository comment listings leave out the kind whose unit is disabled (Gitea 28.2.0 `ListIssues`, `ListRepoIssueComments`) and answer 404 only when both are. Each kind is therefore measured on its own: with the pull request unit disabled, `issues` and every issue measure of `collaboration.byKind` stay measured, and only the pull request measures (`pullRequests`, `reviews`, `reviewComments`, the pull request kinds and states of `byKind`) and the mixed measures that include them (`comments`, `reactions`, `attachments`, `attachmentBytes`) are `notMeasured`, and the reverse. An issue unit configured as an external tracker keeps `features.issues` true but lists no issue, so its issue measures are `notMeasured` too, never a complete zero. A repository record whose `has_issues` disagrees with its trackers fails the repository unit with `inconsistent-issue-unit`, and one whose `projects_mode` is not `repo`, `owner` or `all` with `invalid-projects-mode` (`invalid-string` when it is missing); Gitea 28.2.0 cannot produce either state, so they mean a forge the reader was not built against (S8 U3 ruling, Q3). A disabled wiki hides its pages, and a projects unit that allows only owner boards (`projects_mode` `owner`) hides the repository's boards (`collaboration.projects`), which Gitea still serves while the projects unit is disabled. Labels, milestones, releases and Actions stay readable while their units are disabled.
 - Gitea 28 answers 404 to every pull request route of an archived repository, reads included. The reviews of each pull request are still requested; when an archived repository answers 404 there, `reviews` and `reviewComments` are `partial` with the reason `repository-archived` (in `incompleteReasons` as `repository.collaboration.reviews: repository-archived`). Its issues, pull requests, comments and `refs/pull/*` stay measured. A 404 in a repository that is not archived stays `http-404`.
 
+#### Collaboration records
+
+Issues are recorded only when discovery selects the collaboration class: `reader.discover(signal, { classes: ['collaboration'] })` sets `discovery.collaboration: true`, and `units()` then adds one `{ kind: 'collaboration', owner, name, id }` unit per repository, keyed by the repository's discovered id (S8 ruling D12). A discovery that selects the class while a repository has no id rejects in `units()` with `repository-id-missing`, and composing it names `collaboration: repository-id-missing`; it is never keyed by name. Without the class, discovery carries no `collaboration`, no collaboration unit is measured, and the composed inventory has neither `collaboration` nor any organization's `labelRecords`, so the records are unread. The classes combine: `{ classes: ['packages', 'collaboration'] }`.
+
+A collaboration unit returns an `IForgeSourceCollaborationInventory` (`@foss.global/interfaces` 3.4), read with GETs and the administrator's token, never through `Sudo`:
+
+- The repository must still answer its name with the discovered id, else the unit fails with `repository-identity-changed`.
+- `labels` is every label of the repository, used or not, and `milestones` every milestone (`state=all`), each sorted by numeric id. Organization labels are not repeated here: each organization owner records them as `labelRecords`, and an issue's `labelIds` may name either.
+- `highestNumber` is the highest number Gitea's issue listing holds, issues and pull requests together, since they share one sequence; `0` when it lists none, and not measured when both units are disabled. A deleted number, or one a disabled unit hides, is invisible to every read, so Gitea may have allocated higher ones (S8 ruling D1).
+- `issues` holds every issue, never a pull request, sorted by number, with its comments sorted by id. Title, body, comment bodies, logins and `ref` are verbatim, never trimmed; times are Gitea's RFC 3339 strings as served. Each issue records its poster, Gitea's original author (null when it reports none), assignees, label, milestone and project ids, `locked`, `pinOrder`, `dueDate`, `timeEstimate` and the counts of its tracked times (`/times`), dependencies (`/dependencies`), attachments and reactions; each comment its poster, original author, times and attachment and reaction counts. Gitea's `content_version`, a counter for concurrent edits, is not recorded.
+- `issues` is `notMeasured`, and no issue's comments, reactions, tracked times or dependencies are requested, while Gitea's API hides them: when the issue unit is disabled or an external tracker, when time tracking is switched off for the repository (`internal_tracker.enable_time_tracker`) or the instance (`/settings/repository` `time_tracking_disabled`), or when dependencies are switched off (`internal_tracker.enable_issue_dependencies`). Gitea 28.2.0 then answers 404 to every issue's `/times` or `/dependencies`, and a refused read must never count as none (S8 U1 ruling). Each such case leaves the repository's issues to the owner's per-repository decision (S8 ruling D13); switching the setting on at the source resolves it. Labels and milestones stay readable in every case.
+- `issues` is also `notMeasured`, again without a read of any issue, when Gitea imported the repository (its record's `original_url` is not empty) and the listing holds at least one issue, with the reason "Gitea imported this repository (original_url is set); its API names the importing account as poster and never reports the original author." Gitea's API names the account that ran the import as the poster of every imported issue and comment and never reports the original author (see the facts below), so recording them would credit the wrong account (S8 U3 ruling, Q1). Comments are part of their issues, so the rule covers them. An imported repository without issues keeps a complete empty list. The rule does not depend on `mirror`: a mirror converted to a normal repository keeps its `original_url`. `original_url` itself is never recorded, and a record without it as a string fails the unit with `invalid-string`. A forge whose API fills the original author has it recorded as `originalAuthor`.
+- A unit is read whole or fails, never partly: any listing that does not finish fails it with the listing's reason, and so do an issue naming a milestone the listing lacks (`issue-milestone-unlisted`), an issue number listed twice (`duplicate-number`), an original author id without a name (`invalid-original-author`) and a result over `forgeSourceInventoryUnitMaxBytes` (`unit-over-bound`). A resumed run measures a failed unit again.
+
+`composeGiteaSourceInventory` carries `collaboration`, sorted by owner and name, and every organization's `labelRecords` (null while its `labels` count is not complete) exactly when discovery selects collaboration. A unit that failed, was not measured or answers for another name adds `collaboration: unit failed: <code>` or `collaboration: unit not measured`, and a list that is `notMeasured` adds its path, such as `collaboration.issues: <reason>`. Owner and repository results stored by a reader before this version lack `labelRecords`, `projects` and `collaboration.byKind`; composing them names each as a reason, so the inventory stays incomplete until those units are measured again.
+
+Gitea 28.2.0 facts behind the records, verified with the forgefixtures Gitea:
+- Label and milestone listings are not gated by the issue unit: they answer while it is disabled (the routes carry no unit check, `routers/api/v1/api.go`).
+- `/issues/{index}/times` answers 404 while time tracking is off for the repository, and `/issues/{index}/dependencies` while dependencies are off.
+- `/orgs/{org}/projects` and `/users/{user}/projects` answer the site administrator's token for private organizations and users alike. A repository's `/projects` keeps listing its boards while its projects unit is disabled (Gitea then reports `projects_mode` `all`) and answers 404 while `projects_mode` is `owner`.
+- Gitea applies `internal_tracker` only beside `has_issues: true`, and `projects_mode` only beside `has_projects: true`, in a repository edit.
+- An issue's comments and a comment's reactions are served whole, without pages (`ListIssueComments` takes no page options); the reader requests them once and checks the rows against `X-Total-Count` when Gitea sends it.
+- Gitea's REST API never fills `original_author` or `original_author_id` of an issue or comment (Gitea 28.2.0 `services/convert/issue.go` `toIssue` and `services/convert/issue_comment.go` `ToAPIComment` do not set them), so `originalAuthor` is null for all content. Content Gitea itself imported from another service keeps its source authors only in Gitea's database: through the API every such issue and comment reads as posted by the account that ran the import (`services/migrations/gitea_uploader.go`), as the fixture test shows with an import from Gitea's own loopback listener. This is why an imported repository's issues are `notMeasured` rather than recorded.
+
 #### Packages
 
 Packages are measured only when discovery selects their class: `reader.discover(signal, { classes: ['packages'] })` lists every package from the administrator package listing (`/admin/packages`, user-owned packages included) as `discovery.packages`, and `units()` then adds one unit per package. Without the class, discovery carries no `packages`, no package unit is measured, and the composed inventory has neither `packages` nor `totals.packageContent`, so the package class is unread; a stored discovery from an earlier reader composes as before. An unknown class rejects with `invalid-options`.
@@ -200,7 +224,7 @@ The package reads take selectors from the inventory's package records: the packa
 - `readPackageDocument(package, version, kind, options?)` returns a version's metadata with the SHA-256 of the returned bytes, which a consumer records beside the version id:
   - `npm-version`: the version document.
   - `swift-release`: the release metadata.
-  - `swift-manifest`: `Package.swift`, which must answer 200. With `{ swiftVersion }` (`5.8`, `5.9.1`: trimmed as Gitea keys alternate manifests, the patch only when it is not zero; anything else rejects with `swift-version-invalid` before any request) it reads `Package@swift-<v>.swift` through `?swift-version=` without following a redirect, and resolves `null` only when Gitea answers 303 to the release's own `Package.swift` URL, its answer for a version it holds no manifest for. Any other redirect rejects with `swift-manifest-redirect-unexpected`, any other status with `http-<status>`.
+  - `swift-manifest`: `Package.swift`, which must answer 200. With `{ swiftVersion }` (`5.8`, `5.9.1`: trimmed as Gitea keys alternate manifests, two or three segments without leading zeros, the patch only when it is not zero, each segment at most 9223372036854775807; anything else rejects with `swift-version-invalid` before any request) it reads `Package@swift-<v>.swift` through `?swift-version=` without following a redirect, and resolves `null` only when Gitea answers 303 to the release's own `Package.swift` URL, its answer for a version it holds no manifest for. Any other redirect rejects with `swift-manifest-redirect-unexpected`, any other status with `http-<status>`.
   - `cargo-index-entry`: the version's line of the sparse index; a missing line rejects with `package-document-missing`.
   - `cargo-description`: `{"description":…}` from the crate's entry in the Cargo search (`api/v1/crates?q=<name>`, the entry with exactly that name, read page by page, at most 200 pages of 50). Gitea's search describes only the version with the highest id, so its `max_version` must be the requested version; otherwise, or when no entry has the name, it rejects with `package-document-missing`, and a search that has not run out after 200 pages with `cargo-search-over-bound`.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@foss.global/codefeed',
-  version: '5.3.0',
+  version: '5.5.0',
   description: 'The @foss.global/codefeed module generates commit/activity feeds from forge providers including Gitea and GitManager.'
 }