@foss.global/codefeed 5.1.0 → 5.2.0

package/dist_ts/forgeinventory.client.js

@@ -1,9 +1,9 @@
 import * as validation from './forgeinventory.validation.js';
 /**
- * One bounded, credential-scoped JSON read at a time, a GET or a POST with a
- * JSON body: a per-request deadline, a response-size budget and a strict JSON
- * content type. Failures surface as
- * `ForgeInventoryError` codes that never contain bodies, URLs or credentials.
+ * One bounded, credential-scoped read at a time, a GET or a POST with a JSON
+ * body: a per-request deadline, a response-size budget and, for JSON, a
+ * strict content type. Failures surface as `ForgeInventoryError` codes that
+ * never contain bodies, URLs or credentials.
  */
 export class ForgeRequestClient {
     #options;
@@ -13,6 +13,24 @@ export class ForgeRequestClient {
     }
     get metrics() { return { ...this.#metrics }; }
     async request(url, requestArg = {}) {
+        const mediaType = requestArg.mediaType ?? 'application/json';
+        const response = await this.#read(url, {
+            signal: requestArg.signal, maxResponseBytes: requestArg.maxResponseBytes, headers: requestArg.headers, accept: mediaType, requiredMediaType: mediaType,
+            ...(requestArg.json === undefined ? {} : { body: { mediaType, bytes: new TextEncoder().encode(JSON.stringify(requestArg.json)) } }),
+        });
+        try {
+            return { body: JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(response.bytes)), headers: response.headers };
+        }
+        catch {
+            throw new validation.ForgeInventoryError('request-or-json-failed');
+        }
+    }
+    /** A GET whose body is returned as the bytes that arrived, with the media type the response declared. */
+    async requestBytes(url, requestArg) {
+        const response = await this.#read(url, requestArg);
+        return { bytes: response.bytes, mediaType: mediaTypeOf(response.headers), headers: response.headers };
+    }
+    async #read(url, requestArg) {
         const { signal } = requestArg;
         const maxBytes = requestArg.maxResponseBytes ?? this.#options.maxResponseBytes;
         if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
@@ -27,17 +45,18 @@ export class ForgeRequestClient {
         let bodyChunks;
         try {
             this.#metrics.requests++;
-            const mediaType = requestArg.mediaType ?? 'application/json';
-            const requestBody = requestArg.json === undefined ? undefined : new TextEncoder().encode(JSON.stringify(requestArg.json));
-            const headers = { accept: mediaType, ...(requestBody ? { 'content-type': mediaType } : {}), ...requestArg.headers, ...this.#options.headers };
-            const response = await this.#options.transport(url, headers, controller.signal, requestBody);
+            const headers = {
+                accept: requestArg.accept, ...(requestArg.body ? { 'content-type': requestArg.body.mediaType } : {}), ...requestArg.headers, ...this.#options.headers,
+            };
+            const response = await this.#options.transport(url, headers, controller.signal, requestArg.body?.bytes);
             bodyChunks = response.body?.[Symbol.asyncIterator]();
             if (response.status === 429)
                 this.#metrics.rateLimitedRequests++;
             if (response.status !== 200)
                 throw new validation.ForgeInventoryError(`http-${response.status}`);
-            if (response.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== mediaType || !bodyChunks)
+            if ((requestArg.requiredMediaType !== undefined && mediaTypeOf(response.headers) !== requestArg.requiredMediaType) || !bodyChunks) {
                 throw new validation.ForgeInventoryError('invalid-content-type');
+            }
             const chunks = [];
             let bytes = 0;
             while (true) {
@@ -52,11 +71,9 @@ export class ForgeRequestClient {
                     throw new validation.ForgeInventoryError('request-aborted-or-timed-out');
                 chunks.push(result.value);
             }
-            const text = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
-            const body = JSON.parse(text);
             if (controller.signal.aborted || Date.now() >= deadline)
                 throw new validation.ForgeInventoryError('request-aborted-or-timed-out');
-            return { body, headers: response.headers };
+            return { bytes: Buffer.concat(chunks), headers: response.headers };
         }
         catch (error) {
             if (error instanceof validation.ForgeInventoryError)
@@ -75,4 +92,6 @@ export class ForgeRequestClient {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+/** A response's media type without parameters, lowercased; null when it sent none. */
+const mediaTypeOf = (headersArg) => headersArg.get('content-type')?.split(';')[0].trim().toLowerCase() || null;
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/giteasourceinventory.packages.d.ts

@@ -0,0 +1,46 @@
+import * as plugins from './plugins.js';
+type IPackageRef = plugins.fossInterfaces.data.IForgeSourcePackageRef;
+type IPackageRecord = plugins.fossInterfaces.data.IForgeSourcePackageInventory;
+type IPackageContentTotals = plugins.fossInterfaces.data.IForgeSourcePackageContentTotals;
+/** Media types Gitea serves an index or a manifest list as; an index candidate must be one of them. */
+export declare const containerIndexMediaTypes: readonly string[];
+/** Every manifest media type Gitea serves: images, indexes and manifest lists, OCI and Docker. */
+export declare const containerManifestMediaTypes: readonly string[];
+/** A package type as Gitea names it; it names reason paths, so it must be one of Gitea's plain identifiers. */
+export declare const packageTypePattern: RegExp;
+/** The key of a package within one instance: owner, type and name, which Gitea keeps unique (the name without case). */
+export declare const packageKey: (refArg: IPackageRef) => string;
+/** Orders packages by owner, type and name in code-unit order. */
+export declare const comparePackages: (aArg: IPackageRef, bArg: IPackageRef) => number;
+/** The path segment(s) of an npm package in Gitea's npm registry: the name unencoded, as Gitea's npm routes match it. */
+export declare const npmPackagePath: (nameArg: string) => string;
+/** The path of a crate's entry in the Cargo sparse index, lowercased, per the Cargo registry index layout. */
+export declare const cargoIndexPath: (nameArg: string) => string;
+/** The scope and name of a Swift package stored as `scope.name`. */
+export declare const swiftPackageParts: (nameArg: string) => {
+    scope: string;
+    name: string;
+};
+/**
+ * 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
+ * version without one.
+ */
+export declare const containerManifestDigest: (packageArg: IPackageRecord, versionIdArg: string) => string | null;
+/**
+ * The version ids of a package's tagged-and-referenced selection: for a
+ * container package the tagged versions and the versions holding a manifest
+ * a tagged index references; every version of any other type.
+ */
+export declare const taggedAndReferencedVersionIds: (packageArg: IPackageRecord) => Set<string>;
+/**
+ * The distinct content of an inventory's packages, `totals.packageContent`:
+ * a pure function of the discovered packages and the records their units
+ * returned. Every SHA-256 counts once per scope, globally and per owner, each
+ * by type, over all versions and over the tagged versions with the manifests
+ * their indexes reference. A measure is complete only when every discovered
+ * package of its scope has a record; otherwise it is partial with the sum of
+ * the records read. Records of packages discovery does not list are ignored.
+ */
+export declare const composeGiteaPackageContent: (discoveredArg: readonly IPackageRef[], packagesArg: readonly IPackageRecord[]) => IPackageContentTotals;
+export {};

package/dist_ts/giteasourceinventory.packages.js

@@ -0,0 +1,139 @@
+import * as plugins from './plugins.js';
+import * as validation from './forgeinventory.validation.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',
+    'application/vnd.docker.distribution.manifest.list.v2+json',
+]);
+/** Every manifest media type Gitea serves: images, indexes and manifest lists, OCI and Docker. */
+export const containerManifestMediaTypes = Object.freeze([
+    ...containerIndexMediaTypes,
+    'application/vnd.oci.image.manifest.v1+json',
+    'application/vnd.docker.distribution.manifest.v2+json',
+]);
+/** A package type as Gitea names it; it names reason paths, so it must be one of Gitea's plain identifiers. */
+export const packageTypePattern = /^[a-z][a-z0-9_-]{0,31}$/;
+/** Gitea's npm name rule (`modules/packages/npm/creator.go`): `name` or `@scope/name`, URL-safe as it stands. */
+const npmNamePattern = /^(?:@[a-z0-9-][a-z0-9-._]*\/)?[a-z0-9-][a-z0-9-._]*$/;
+/** Gitea's Cargo crate name rule (`modules/packages/cargo/parser.go`). */
+const cargoNamePattern = /^[A-Za-z][A-Za-z0-9-_]{0,63}$/;
+/** Gitea's Swift scope and name rules (`routers/api/packages/swift/swift.go`); it stores the package as `scope.name`. */
+const swiftPackagePattern = /^([A-Za-z0-9][A-Za-z0-9-]{0,38})\.([A-Za-z0-9][A-Za-z0-9-_]{0,99})$/;
+const compareText = (aArg, bArg) => (aArg < bArg ? -1 : aArg > bArg ? 1 : 0);
+/** The key of a package within one instance: owner, type and name, which Gitea keeps unique (the name without case). */
+export const packageKey = (refArg) => `${refArg.owner}/${refArg.type}/${refArg.name}`;
+/** Orders packages by owner, type and name in code-unit order. */
+export const comparePackages = (aArg, bArg) => compareText(aArg.owner, bArg.owner) || compareText(aArg.type, bArg.type) || compareText(aArg.name, bArg.name);
+/** The path segment(s) of an npm package in Gitea's npm registry: the name unencoded, as Gitea's npm routes match it. */
+export const npmPackagePath = (nameArg) => {
+    if (!npmNamePattern.test(nameArg) || nameArg.length > 214)
+        throw new validation.ForgeInventoryError('invalid-npm-name');
+    return nameArg;
+};
+/** The path of a crate's entry in the Cargo sparse index, lowercased, per the Cargo registry index layout. */
+export const cargoIndexPath = (nameArg) => {
+    if (!cargoNamePattern.test(nameArg))
+        throw new validation.ForgeInventoryError('invalid-cargo-name');
+    const name = nameArg.toLowerCase();
+    if (name.length === 1)
+        return `1/${name}`;
+    if (name.length === 2)
+        return `2/${name}`;
+    if (name.length === 3)
+        return `3/${name[0]}/${name}`;
+    return `${name.slice(0, 2)}/${name.slice(2, 4)}/${name}`;
+};
+/** The scope and name of a Swift package stored as `scope.name`. */
+export const swiftPackageParts = (nameArg) => {
+    const match = swiftPackagePattern.exec(nameArg);
+    if (!match)
+        throw new validation.ForgeInventoryError('invalid-swift-name');
+    return { scope: match[1], name: match[2] };
+};
+/**
+ * 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
+ * version without one.
+ */
+export const containerManifestDigest = (packageArg, versionIdArg) => {
+    const blob = packageArg.blobs.find((blobArg) => blobArg.files.some((fileArg) => fileArg.versionId === versionIdArg && fileArg.name === 'manifest.json'));
+    return blob ? `sha256:${blob.sha256}` : null;
+};
+/**
+ * The version ids of a package's tagged-and-referenced selection: for a
+ * container package the tagged versions and the versions holding a manifest
+ * a tagged index references; every version of any other type.
+ */
+export const taggedAndReferencedVersionIds = (packageArg) => {
+    if (packageArg.type !== 'container')
+        return new Set(packageArg.versions.map((versionArg) => versionArg.id));
+    const tagged = packageArg.versions.filter((versionArg) => !versionArg.version.startsWith('sha256:'));
+    const referenced = new Set(tagged.flatMap((versionArg) => versionArg.references ?? []));
+    const selected = new Set(tagged.map((versionArg) => versionArg.id));
+    for (const version of packageArg.versions) {
+        const digest = containerManifestDigest(packageArg, version.id);
+        if (digest !== null && referenced.has(digest))
+            selected.add(version.id);
+    }
+    return selected;
+};
+const contentMeasure = (sumArg, missingArg) => {
+    const blobs = BigInt(sumArg.blobs.size);
+    const bytes = [...sumArg.blobs.values()].reduce((totalArg, sizeArg) => totalArg + sizeArg, 0n);
+    if (missingArg === 0)
+        return { blobs: { status: 'complete', value: blobs.toString() }, bytes: { status: 'complete', value: bytes.toString() } };
+    const reason = `Package units not measured: ${missingArg}.`;
+    const partial = (valueArg) => ({ status: 'partial', observedValue: valueArg.toString(), reason });
+    return { blobs: partial(blobs), bytes: partial(bytes) };
+};
+/** Distinct content of a set of package records over both selections; `missingArg` packages of the set were not read. */
+const selection = (packagesArg, missingArg) => {
+    const all = { blobs: new Map() };
+    const tagged = { blobs: new Map() };
+    for (const record of packagesArg) {
+        const selected = taggedAndReferencedVersionIds(record);
+        for (const blob of record.blobs) {
+            const size = BigInt(blob.size);
+            all.blobs.set(blob.sha256, size);
+            if (blob.files.some((fileArg) => selected.has(fileArg.versionId)))
+                tagged.blobs.set(blob.sha256, size);
+        }
+    }
+    return { allVersions: contentMeasure(all, missingArg), taggedAndReferenced: contentMeasure(tagged, missingArg) };
+};
+/** A group of packages with its content by type; `refsArg` are the group's discovered packages. */
+const group = (refsArg, recordsArg) => {
+    const read = (refs) => refs.flatMap((refArg) => {
+        const record = recordsArg.get(packageKey(refArg));
+        return record ? [record] : [];
+    });
+    const missing = (refs) => refs.filter((refArg) => !recordsArg.has(packageKey(refArg))).length;
+    const types = [...new Set(refsArg.map((refArg) => refArg.type))].sort(compareText);
+    return {
+        ...selection(read(refsArg), missing(refsArg)),
+        types: types.map((typeArg) => {
+            const refs = refsArg.filter((refArg) => refArg.type === typeArg);
+            return { type: typeArg, ...selection(read(refs), missing(refs)) };
+        }),
+    };
+};
+/**
+ * The distinct content of an inventory's packages, `totals.packageContent`:
+ * a pure function of the discovered packages and the records their units
+ * returned. Every SHA-256 counts once per scope, globally and per owner, each
+ * by type, over all versions and over the tagged versions with the manifests
+ * their indexes reference. A measure is complete only when every discovered
+ * package of its scope has a record; otherwise it is partial with the sum of
+ * the records read. Records of packages discovery does not list are ignored.
+ */
+export const composeGiteaPackageContent = (discoveredArg, packagesArg) => {
+    const discovered = new Set(discoveredArg.map(packageKey));
+    const records = new Map(packagesArg.filter((recordArg) => discovered.has(packageKey(recordArg))).map((recordArg) => [packageKey(recordArg), recordArg]));
+    const refs = [...new Map(discoveredArg.map((refArg) => [packageKey(refArg), { owner: refArg.owner, type: refArg.type, name: refArg.name }])).values()];
+    const owners = [...new Set(refs.map((refArg) => refArg.owner))].sort(compareText);
+    return {
+        global: group(refs, records),
+        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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"}

package/dist_ts/index.d.ts

@@ -61,3 +61,4 @@ export * from './classes.giteasourceinventory.js';
 export * from './classes.giteasourcetransfer.js';
 export * from './classes.lfsbatchclient.js';
 export { GitScratchBudget, mirrorScratchBytes } from './giteasourceinventory.git.js';
+export { composeGiteaPackageContent } from './giteasourceinventory.packages.js';

package/dist_ts/index.js

@@ -433,4 +433,5 @@ export * from './classes.giteasourceinventory.js';
 export * from './classes.giteasourcetransfer.js';
 export * from './classes.lfsbatchclient.js';
 export { GitScratchBudget, mirrorScratchBytes } from './giteasourceinventory.git.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}
+export { composeGiteaPackageContent } from './giteasourceinventory.packages.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}

package/dist_ts/plugins.d.ts

@@ -1,4 +1,4 @@
-import type * as fossInterfaces from '@foss.global/interfaces';
+import * as fossInterfaces from '@foss.global/interfaces';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs/promises';
 import * as http from 'node:http';
@@ -11,7 +11,7 @@ import * as interfaces from './interfaces/index.js';
 export { interfaces, };
 import * as lik from '@push.rocks/lik';
 import * as smarttime from '@push.rocks/smarttime';
-export type { fossInterfaces };
+export { fossInterfaces };
 export type TNpmRegistry = import('@push.rocks/smartnpm').NpmRegistry;
 export type TGitManager = import('@foss.global/gitmanager').GitManager;
 export type TGitManagerCommitSummary = import('@foss.global/gitmanager').IGitManagerCommitSummary;

package/dist_ts/plugins.js

@@ -1,3 +1,4 @@
+import * as fossInterfaces from '@foss.global/interfaces';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs/promises';
 import * as http from 'node:http';
@@ -12,7 +13,8 @@ export { interfaces, };
 // @push.rocks
 import * as lik from '@push.rocks/lik';
 import * as smarttime from '@push.rocks/smarttime';
+export { fossInterfaces };
 export const getSmartnpm = async () => import('@push.rocks/smartnpm');
 export const getGitManager = async () => import('@foss.global/gitmanager');
 export { smarttime, lik, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssS0FBSyxNQUFNLFlBQVksQ0FBQztBQUNwQyxPQUFPLEtBQUssR0FBRyxNQUFNLFVBQVUsQ0FBQztBQUNoQyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFFdEQsU0FBUztBQUNULE9BQU8sS0FBSyxVQUFVLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsT0FBTyxFQUNMLFVBQVUsR0FDWCxDQUFBO0FBRUQsY0FBYztBQUNkLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQVduRCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsS0FBSyxJQUFJLEVBQUUsQ0FBQyxNQUFNLENBQUMsc0JBQXNCLENBQUMsQ0FBQztBQUN0RSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsS0FBSyxJQUFJLEVBQUUsQ0FBQyxNQUFNLENBQUMseUJBQXlCLENBQUMsQ0FBQztBQUUzRSxPQUFPLEVBQ0wsU0FBUyxFQUNULEdBQUcsR0FDSixDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLGNBQWMsTUFBTSx5QkFBeUIsQ0FBQztBQUUxRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxLQUFLLE1BQU0sWUFBWSxDQUFDO0FBQ3BDLE9BQU8sS0FBSyxHQUFHLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsQ0FBQztBQUV0RCxTQUFTO0FBQ1QsT0FBTyxLQUFLLFVBQVUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEVBQ0wsVUFBVSxHQUNYLENBQUE7QUFFRCxjQUFjO0FBQ2QsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxjQUFjLEVBQUUsQ0FBQztBQVMxQixNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsS0FBSyxJQUFJLEVBQUUsQ0FBQyxNQUFNLENBQUMsc0JBQXNCLENBQUMsQ0FBQztBQUN0RSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsS0FBSyxJQUFJLEVBQUUsQ0FBQyxNQUFNLENBQUMseUJBQXlCLENBQUMsQ0FBQztBQUUzRSxPQUFPLEVBQ0wsU0FBUyxFQUNULEdBQUcsR0FDSixDQUFBIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foss.global/codefeed",
-  "version": "5.1.0",
+  "version": "5.2.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": "^0.7.0",
+    "@foss.global/forgefixtures": "^1.0.0",
     "@git.zone/tsrepo": "^2.1.0",
     "@push.rocks/qenv": "^8.2.1",
     "@types/node": "^26.6.6"
   },
   "dependencies": {
     "@foss.global/gitmanager": "^2.4.0",
-    "@foss.global/interfaces": "^3.1.0",
+    "@foss.global/interfaces": "^3.2.1",
     "@push.rocks/lik": "^6.4.4",
     "@push.rocks/smartnpm": "^2.1.3",
     "@push.rocks/smarttime": "^5.0.1"

package/readme.md

@@ -127,11 +127,26 @@ 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 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`.
 
+#### 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`.
+
+A package unit returns an `IForgeSourcePackageInventory` (`@foss.global/interfaces` 3.2): the owner's id, the linked repository's id or `null`, every version Gitea's v1 package API lists (id, version, `created_at` verbatim) and every distinct file content once, by SHA-256 with its size, with the files holding it (version id, file id, name). A unit is read whole or fails, never as a partial record:
+
+- Container: a version whose file list is exactly `manifest.json` is an index candidate, because Gitea stores an index's manifest and nothing else. Each candidate is read by digest from the registry (`/v2/<owner>/<image>/manifests/<digest>`) with the reader's Basic credentials and the index media types; the bytes must hash to the listed SHA-256 and the response must be an OCI index or a Docker manifest list, else the unit fails with `unexpected-manifest-shape`. Its `references` are the digests its `manifests` name, sorted, each once. No other manifest is read; a tag is a version whose `version` does not start with `sha256:`.
+- npm: `distTags` is every dist-tag Gitea serves (`/-/package/{name}/dist-tags`), a `latest` Gitea derives when none is stored included, since no read tells the two apart; each version's `deprecated` comes from the package document (`''` when not deprecated). A version missing from the document fails the unit with `npm-version-missing`.
+- Cargo: each version's `yanked` comes from the crate's sparse index; a version missing from it fails the unit with `cargo-index-incomplete`.
+- A listing that does not finish fails the unit with the listing's reason, rows of another package with `package-identity-changed`, and a record over `forgeSourceInventoryUnitMaxBytes` (4 MiB of UTF-8 JSON) with `unit-over-bound`; it is never truncated.
+
+Every read is a GET. Reading an index counts a download of its version in Gitea (`package_version.download_count`), an accepted read stamp (S10 ruling, Addendum 1); every other package read counts nothing.
+
+`totals.packageContent` comes from the exported pure function `composeGiteaPackageContent(discoveredPackages, packageRecords)`, which a consumer can recompose and compare: distinct SHA-256 digests and their bytes for every owner together and per owner, each by type, over all versions and over the tagged versions plus the versions holding a manifest a tagged index references (every version of other types). It sizes stores that keep each digest once, Gitea globally and the native container registry per owner. A measure is complete only when every discovered package in its scope has a record; a failed unit leaves its package out, adds `package: unit failed: <reason>` to `incompleteReasons` and makes the measures of its owner, its type and the whole instance `partial`. Discovery with an empty `packages` list composes `packages: []` and complete zeros.
+
 Listings page until an empty page or the `x-total-count` total is reached. A total that changes mid-listing or disagrees with the rows read, a repeated page, a malformed page, a failed request or the page limit makes that measure `partial` and keeps the rows already read; only a listing that does not exist, such as the wiki of a repository without one, counts as empty. A repository search that lists one repository id twice has shifted under its pages and may have skipped a repository: discovery keeps the first entry and adds `discovery: repositories: duplicate-id` to `incompleteReasons`.
 
 ### Gitea source transfer
 
-`GiteaSourceTransfer` reads one repository's Git data, LFS objects and release assets for the one-time migration, with the same reader credentials as the inventory. It never writes to Gitea: Git is read only through `git-upload-pack`, LFS only through batch `download` requests and their download actions, release assets only through GETs of their attachment.
+`GiteaSourceTransfer` reads one repository's Git data, LFS objects and release assets, and package content, for the one-time migration, with the same reader credentials as the inventory. It never writes to Gitea: Git is read only through `git-upload-pack`, LFS only through batch `download` requests and their download actions, release assets only through GETs of their attachment, packages only through GETs of the registries and the v1 package API.
 
 ```ts
 import { GitManager } from '@foss.global/gitmanager';
@@ -175,6 +190,17 @@ While the import runs, GitManager holds `target`: writes to it, such as `initBar
 
 `downloadReleaseAsset(repository, releaseId, asset)` takes the release id and the asset's `id`, `uuid`, `name` and `size` as the inventory recorded them; anything else rejects with `release-asset-invalid` before any request. It reads the repository by id, then `GET /api/v1/repos/{owner}/{name}/releases/{releaseId}`, which must still carry an asset with the same id, uuid, name and size; otherwise it rejects with `release-asset-identity-changed` (a deleted release with `http-404`). The download count is not compared. It then GETs `{baseUrl}/attachments/{uuid}` with the reader's `token` authorization: no redirect is followed and no range is asked for, so any answer but 200 rejects, with `http-<status>` or, for a refused redirect, `release-asset-download-failed`, and a `content-length` other than `size` rejects with `release-asset-size-mismatch`. No digest is computed while the bytes stream: the stream counts them and holds back the last chunk until exactly `size` bytes have arrived and both identity reads have passed once more, so a consumer never receives a complete asset that is short, long or no longer the recorded one. Otherwise it errors with `release-asset-size-overrun`, `release-asset-short-body`, `repository-identity-changed` or `release-asset-identity-changed`. Content digests come from the content itself, such as a publisher's `SHA256SUMS` asset or the importer's own hash. An abort errors it with `request-aborted`, a download longer than `releaseAssetTimeoutMs` (default 30 minutes, at most six hours) or idle for `requestTimeoutMs` with `release-asset-transfer-timed-out`. A failed request is explained by the identity reads as for `downloadLfsObject`. Destroying the stream ends the download; the download's connections close with the stream. The stream fails internally with `release-asset-transfer-failed` when body bytes still arrive after the download has ended, which happens only once the stream is destroyed, so a reader of the stream does not see it.
 
+#### Package content
+
+The package reads take selectors from the inventory's package records: the package (`owner`, `ownerId`, `type`, `name`), a version (`id`, `version`) and content (`sha256`, `size`, with the file `name` for a version's file). A malformed selector rejects with `package-invalid`, `package-version-invalid` or `package-content-invalid` before any request.
+
+- `readContainerManifest(package, digest)` reads a manifest by digest from the registry with the reader's Basic credentials and returns its exact bytes and its `Content-Type` verbatim, the media type it was pushed with. The bytes must hash to `digest`, and a `Docker-Content-Digest` must name it (`package-manifest-digest-mismatch`); a type that is no OCI or Docker image manifest, index or manifest list rejects with `package-manifest-media-type-invalid`.
+- `downloadContainerBlob(package, content)` streams a config or layer by digest. Manifests and blobs are content-addressed, so no identity read accompanies them.
+- `downloadPackageFile(package, version, file)` streams a generic file, an npm tarball (`{name}/-/{version}/{file}`), a Swift source archive (with `Accept: application/vnd.swift.registry.v1+zip`) or a crate, with the reader's `token` authorization; container content uses the two reads above (`package-type-unsupported`).
+- `readPackageDocument(package, version, kind)` returns a version's metadata as Gitea serves it, with its SHA-256: `npm-version` (the version document), `swift-release` (release metadata), `swift-manifest` (`Package.swift`) or `cargo-index-entry` (the version's line of the sparse index, without its newline; a missing line rejects with `package-document-missing`). A kind of another type rejects with `package-document-kind-invalid`, another media type with `invalid-content-type`.
+
+A version's file and documents are read between two identity reads of `GET /api/v1/packages/{owner}/{type}/{name}/{version}`, which must still carry the recorded version id, owner id, type and name: a version deleted and published again rejects with `package-version-identity-changed`, a deleted one with `http-404`, also when the read itself failed. Streams verify while they pass: the last chunk is held back until exactly `size` bytes have arrived, their SHA-256 is `sha256` and, for a version's file, the closing identity read has passed; otherwise they error with `package-content-size-overrun`, `package-content-short-body`, `package-content-digest-mismatch` or the identity code, and a `content-length` other than `size` rejects with `package-content-size-mismatch`. An abort errors with `request-aborted`, a download longer than `packageTransferTimeoutMs` (default 30 minutes, at most six hours) or idle for `requestTimeoutMs` with `package-content-transfer-timed-out`. Reading a manifest or a version's file counts a download of its version in Gitea, an accepted read stamp (S10 ruling, item 8); blobs and documents count nothing.
+
 ### Git LFS batch client
 
 `LfsBatchClient` is a provider-neutral Git LFS batch API client with the `basic` transfer adapter, bound to one LFS endpoint and its credential. `GiteaSourceTransfer` downloads through it; the migration uploads to the native Git service through it.
@@ -365,7 +391,7 @@ The repo contains:
 - A mocked pagination test that does not require network.
 - A GitManager provider mapping test using a local test stub.
 - A default-deny GitManager public-client mapping test using a local test stub.
-- A mocked `GiteaSourceInventory` test, Git-level `GiteaSourceInventory` and `GiteaSourceTransfer` tests and a release asset download test against a local HTTPS Git, LFS batch, REST and attachment server (needs `openssl` and `git http-backend`), and an opt-in one against a Docker Gitea from `@foss.global/forgefixtures`, run with `FORGEFIXTURES=gitea pnpm test` (Docker required).
+- A mocked `GiteaSourceInventory` test and a mocked package inventory test, Git-level `GiteaSourceInventory` and `GiteaSourceTransfer` tests, a release asset download test and a package transfer test against local HTTPS servers (needs `openssl` and `git http-backend`), and an opt-in one against a Docker Gitea from `@foss.global/forgefixtures`, run with `FORGEFIXTURES=gitea pnpm test` (Docker required). It checks every package record field for field against the fixture's manifest, the distinct content against an independent computation, every transfer read, and, with the fixture's state snapshots, that the package inventory and transfer reads change nothing in Gitea but `package_version.download_count` (once per lead-file read) and the administrator token's `access_token.updated_unix`.
 - An `LfsBatchClient` test against local loopback LFS servers over HTTP and over HTTPS with a private CA.
 
 Run tests:

package/ts/00_commitinfo_data.ts

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