@foss.global/codefeed 2.1.0 → 3.0.0

package/dist_ts/forgeinventory.client.js

@@ -1,7 +1,8 @@
 import * as validation from './forgeinventory.validation.js';
 /**
- * One bounded, credential-scoped JSON GET at a time: a per-request deadline, a
- * response-size budget and a strict JSON content type. Failures surface as
+ * 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.
  */
 export class ForgeRequestClient {
@@ -26,14 +27,16 @@ export class ForgeRequestClient {
         let bodyChunks;
         try {
             this.#metrics.requests++;
-            const headers = { accept: 'application/json', ...requestArg.headers, ...this.#options.headers };
-            const response = await this.#options.transport(url, headers, controller.signal);
+            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);
             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() !== 'application/json' || !bodyChunks)
+            if (response.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== mediaType || !bodyChunks)
                 throw new validation.ForgeInventoryError('invalid-content-type');
             const chunks = [];
             let bytes = 0;
@@ -72,4 +75,4 @@ export class ForgeRequestClient {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/forgeinventory.transport.d.ts

@@ -6,11 +6,12 @@ export interface IForgeTransportResponse {
     body: AsyncIterable<Uint8Array> | null;
 }
 /**
- * Sends one credential-scoped GET and resolves once response headers arrive.
- * A redirect status rejects and is never followed; aborting `signal` discards
- * the connection, also while the body is still being read.
+ * Sends one credential-scoped GET, or a POST of `body` when one is given, and
+ * resolves once response headers arrive. A redirect status rejects and is
+ * never followed; aborting `signal` discards the connection, also while the
+ * body is still being read.
  */
-export type TForgeTransport = (url: URL, headers: Record<string, string>, signal: AbortSignal) => Promise<IForgeTransportResponse>;
+export type TForgeTransport = (url: URL, headers: Record<string, string>, signal: AbortSignal, body?: Uint8Array<ArrayBuffer>) => Promise<IForgeTransportResponse>;
 /** Node's global `fetch` with the process-wide default trust store. */
 export declare const globalFetchTransport: TForgeTransport;
 /**

package/dist_ts/forgeinventory.transport.js

@@ -8,8 +8,8 @@ const redirectStatuses = new Set([301, 302, 303, 307, 308]);
  */
 const idleSocketTimeoutMs = 4_000;
 /** Node's global `fetch` with the process-wide default trust store. */
-export const globalFetchTransport = async (url, headers, signal) => {
-    const response = await fetch(url, { method: 'GET', headers, redirect: 'error', credentials: 'omit', signal });
+export const globalFetchTransport = async (url, headers, signal, body) => {
+    const response = await fetch(url, { method: body ? 'POST' : 'GET', headers, body, redirect: 'error', credentials: 'omit', signal });
     return { status: response.status, headers: response.headers, body: response.body };
 };
 /**
@@ -19,11 +19,11 @@ export const globalFetchTransport = async (url, headers, signal) => {
  */
 export const createHttpsTransport = (caCertificates) => {
     const agent = new plugins.https.Agent({ ca: caCertificates, keepAlive: true, timeout: idleSocketTimeoutMs });
-    return (url, headers, signal) => new Promise((resolve, reject) => {
+    return (url, headers, signal, body) => new Promise((resolve, reject) => {
         if (signal.aborted)
             return reject(signal.reason);
         // Bodies are read as sent, so ask for them without a content coding.
-        const request = plugins.https.request(url, { method: 'GET', headers: { ...headers, 'accept-encoding': 'identity' }, agent });
+        const request = plugins.https.request(url, { method: body ? 'POST' : 'GET', headers: { ...headers, 'accept-encoding': 'identity' }, agent });
         // Stays attached for the request's lifetime, so a connection failure while
         // the body is read never becomes an unhandled 'error' event.
         request.on('error', reject);
@@ -52,7 +52,7 @@ export const createHttpsTransport = (caCertificates) => {
                 request.destroy();
             }
         });
-        request.end();
+        request.end(body);
     });
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/giteasourceinventory.git.d.ts

@@ -0,0 +1,70 @@
+import * as plugins from './plugins.js';
+import type { ForgeRequestClient } from './forgeinventory.client.js';
+type IGitCounts = Omit<plugins.fossInterfaces.data.IForgeSourceGitCounts, 'reportedSizeKiB'>;
+type ILfsCounts = plugins.fossInterfaces.data.IForgeSourceLfsCounts;
+export interface IGiteaMirrorSource {
+    /** Instance root without a trailing slash. */
+    baseUrl: string;
+    owner: string;
+    name: string;
+    /** The reader's login and token; Gitea accepts a token as the Basic password for Git and LFS. */
+    username: string;
+    token: string;
+    caCertificates?: string[];
+    /** Private directory that holds the temporary mirror. */
+    workDir: string;
+    /** The repository size Gitea reports, which sizes the mirror's scratch reservation. */
+    reportedSizeKiB: bigint;
+    /** Wall-clock limit of the mirror clone. */
+    timeoutMs: number;
+    /** Sends LFS batch reads with the reader's Basic credentials. */
+    lfsClient: ForgeRequestClient;
+    signal?: AbortSignal;
+}
+/**
+ * Scratch space reserved for one mirror: twice the size Gitea reports, because
+ * a clone holds received and indexed packs, plus fixed headroom for refs, the
+ * index and a size Gitea has not updated yet.
+ */
+export declare const mirrorScratchBytes: (reportedSizeKiBArg: bigint) => bigint;
+/**
+ * Admits mirror clones on one file system in arrival order while the scratch
+ * they reserve fits its free space. A clone's reservation counts in full until
+ * it is released, although part of it is already written, so the check never
+ * admits more than fits. A clone that does not fit waits until the clones in
+ * flight release their reservations; one that does not fit even alone is
+ * refused.
+ */
+export declare class GitScratchBudget {
+    #private;
+    constructor(freeBytesArg?: (directoryArg: string) => Promise<bigint>);
+    /**
+     * Reserves `bytesArg` in `directoryArg` and resolves with the function that
+     * releases them, or with null when they exceed the free space with no other
+     * clone in flight. Rejects when the free space cannot be read or `signalArg`
+     * aborts.
+     */
+    reserve(directoryArg: string, bytesArg: bigint, signalArg?: AbortSignal): Promise<(() => void) | null>;
+}
+/**
+ * Measures one repository at the Git level: clones every ref Gitea advertises
+ * into a temporary mirror, counts its refs and objects, finds the LFS pointers
+ * of every reachable revision and checks through the LFS batch API which of
+ * their objects Gitea holds. The mirror is removed afterwards. The clone starts
+ * only once its scratch reservation fits the work directory's free space; a
+ * repository too large for it fails with `git-workdir-too-small`.
+ */
+export declare const measureGiteaMirror: (sourceArg: IGiteaMirrorSource) => Promise<{
+    git: IGitCounts;
+    lfs: ILfsCounts;
+}>;
+/**
+ * Asks Gitea's LFS batch API, as a `download`, which referenced objects it
+ * holds: a held object answers with a download action, a missing one with
+ * error 404. Actions, their URLs and headers are never retained.
+ */
+export declare const giteaLfsPresence: (sourceArg: Pick<IGiteaMirrorSource, 'baseUrl' | 'owner' | 'name' | 'lfsClient' | 'signal'>, pointersArg: Array<{
+    oid: string;
+    sizeBytes: number;
+}>) => Promise<ILfsCounts>;
+export {};

package/dist_ts/giteasourceinventory.git.js

@@ -0,0 +1,294 @@
+import * as plugins from './plugins.js';
+import * as validation from './forgeinventory.validation.js';
+/** Objects per LFS batch request. */
+const lfsBatchSize = 100;
+const lfsMediaType = 'application/vnd.git-lfs+json';
+/**
+ * Scratch space reserved for one mirror: twice the size Gitea reports, because
+ * a clone holds received and indexed packs, plus fixed headroom for refs, the
+ * index and a size Gitea has not updated yet.
+ */
+export const mirrorScratchBytes = (reportedSizeKiBArg) => reportedSizeKiBArg * 1024n * 2n + 64n * 1024n * 1024n;
+/** Bytes an unprivileged process may still write to the file system holding `directoryArg`. */
+const statfsFreeBytes = async (directoryArg) => {
+    const stats = await plugins.fs.statfs(directoryArg, { bigint: true });
+    return stats.bavail * stats.bsize;
+};
+/**
+ * Admits mirror clones on one file system in arrival order while the scratch
+ * they reserve fits its free space. A clone's reservation counts in full until
+ * it is released, although part of it is already written, so the check never
+ * admits more than fits. A clone that does not fit waits until the clones in
+ * flight release their reservations; one that does not fit even alone is
+ * refused.
+ */
+export class GitScratchBudget {
+    #freeBytes;
+    #reserved = 0n;
+    /** Settles when the clones ahead of the next arrival have been admitted or refused. */
+    #queue = Promise.resolve();
+    #releaseListeners = new Set();
+    constructor(freeBytesArg = statfsFreeBytes) {
+        this.#freeBytes = freeBytesArg;
+    }
+    /**
+     * Reserves `bytesArg` in `directoryArg` and resolves with the function that
+     * releases them, or with null when they exceed the free space with no other
+     * clone in flight. Rejects when the free space cannot be read or `signalArg`
+     * aborts.
+     */
+    async reserve(directoryArg, bytesArg, signalArg) {
+        const ahead = this.#queue;
+        let admitted;
+        const turn = new Promise((resolve) => { admitted = resolve; });
+        // Followers wait for this turn and every turn ahead of it, even when this one ends early.
+        this.#queue = ahead.then(() => turn);
+        try {
+            await this.#until(ahead, signalArg);
+            for (;;) {
+                // Listens before reading the free space, so a release while it is read is not missed.
+                let listener;
+                const released = new Promise((resolve) => { listener = resolve; });
+                this.#releaseListeners.add(listener);
+                try {
+                    const free = await this.#freeBytes(directoryArg);
+                    if (this.#reserved + bytesArg <= free) {
+                        this.#reserved += bytesArg;
+                        return this.#releaser(bytesArg);
+                    }
+                    if (this.#reserved === 0n)
+                        return null;
+                    await this.#until(released, signalArg);
+                }
+                finally {
+                    this.#releaseListeners.delete(listener);
+                }
+            }
+        }
+        finally {
+            admitted();
+        }
+    }
+    #releaser(bytesArg) {
+        let held = true;
+        return () => {
+            if (!held)
+                return;
+            held = false;
+            this.#reserved -= bytesArg;
+            for (const listener of this.#releaseListeners)
+                listener();
+        };
+    }
+    async #until(promiseArg, signalArg) {
+        signalArg?.throwIfAborted();
+        if (!signalArg)
+            return promiseArg;
+        let abort;
+        const aborted = new Promise((_resolve, reject) => {
+            abort = () => reject(signalArg.reason);
+            signalArg.addEventListener('abort', abort, { once: true });
+        });
+        try {
+            await Promise.race([promiseArg, aborted]);
+        }
+        finally {
+            signalArg.removeEventListener('abort', abort);
+        }
+    }
+}
+/** One budget per file system, shared by every reader in the process. */
+const scratchBudgets = new Map();
+const scratchBudget = async (workDirArg) => {
+    const device = (await plugins.fs.stat(workDirArg, { bigint: true })).dev;
+    let budget = scratchBudgets.get(device);
+    if (!budget) {
+        budget = new GitScratchBudget();
+        scratchBudgets.set(device, budget);
+    }
+    return budget;
+};
+const complete = (valueArg) => ({ status: 'complete', value: BigInt(valueArg).toString() });
+const partial = (observedArg, reasonArg) => ({ status: 'partial', observedValue: BigInt(observedArg).toString(), reason: reasonArg });
+const failedGit = (reasonArg) => {
+    const failed = partial(0, reasonArg);
+    return { branches: failed, tags: failed, pullRequestRefs: failed, otherRefs: failed, objects: failed, objectBytes: failed };
+};
+const failedLfs = (reasonArg) => {
+    const failed = partial(0, reasonArg);
+    return { objects: failed, bytes: failed, missingObjects: failed };
+};
+/**
+ * Fixed reason for a failed step. GitManager errors are never passed on: they
+ * are redacted, but still remote text.
+ */
+const stepFailure = (errorArg, stepArg, signalArg) => signalArg?.aborted ? 'request-aborted' : errorArg instanceof validation.ForgeInventoryError ? errorArg.code : stepArg;
+/**
+ * Measures one repository at the Git level: clones every ref Gitea advertises
+ * into a temporary mirror, counts its refs and objects, finds the LFS pointers
+ * of every reachable revision and checks through the LFS batch API which of
+ * their objects Gitea holds. The mirror is removed afterwards. The clone starts
+ * only once its scratch reservation fits the work directory's free space; a
+ * repository too large for it fails with `git-workdir-too-small`.
+ */
+export const measureGiteaMirror = async (sourceArg) => {
+    const { signal } = sourceArg;
+    if (signal?.aborted)
+        throw new validation.ForgeInventoryError('request-aborted');
+    let release;
+    try {
+        release = await (await scratchBudget(sourceArg.workDir)).reserve(sourceArg.workDir, mirrorScratchBytes(sourceArg.reportedSizeKiB), signal);
+    }
+    catch {
+        const failure = signal?.aborted ? 'request-aborted' : 'git-workdir-failed';
+        return { git: failedGit(failure), lfs: failedLfs(failure) };
+    }
+    if (release === null)
+        return { git: failedGit('git-workdir-too-small'), lfs: failedLfs('git-workdir-too-small') };
+    try {
+        return await measureReservedMirror(sourceArg);
+    }
+    finally {
+        release();
+    }
+};
+const measureReservedMirror = async (sourceArg) => {
+    const { signal } = sourceArg;
+    const { GitManager } = await plugins.getGitManager();
+    let directory;
+    try {
+        directory = await plugins.fs.mkdtemp(plugins.path.join(sourceArg.workDir, 'mirror-'));
+    }
+    catch {
+        return { git: failedGit('git-workdir-failed'), lfs: failedLfs('git-workdir-failed') };
+    }
+    const manager = new GitManager({ dataDir: directory });
+    // Stopping the engine ends the operation in flight.
+    const abort = () => { void manager.stop().catch(() => undefined); };
+    signal?.addEventListener('abort', abort, { once: true });
+    const selector = { org: 'source', repo: 'mirror' };
+    try {
+        try {
+            // An abort while the engine module loaded or the directory was created reached no listener.
+            signal?.throwIfAborted();
+            await manager.start();
+            await manager.importMirror({
+                ...selector,
+                remoteUrl: `${sourceArg.baseUrl}/${encodeURIComponent(sourceArg.owner)}/${encodeURIComponent(sourceArg.name)}.git`,
+                credential: { kind: 'basic', username: sourceArg.username, password: sourceArg.token },
+                caCertificates: sourceArg.caCertificates,
+                timeoutMs: sourceArg.timeoutMs,
+            });
+        }
+        catch (error) {
+            const failure = stepFailure(error, 'git-mirror-failed', signal);
+            return { git: failedGit(failure), lfs: failedLfs(failure) };
+        }
+        const git = await measureRefsAndObjects(manager, selector, signal);
+        let pointers;
+        try {
+            pointers = await manager.listRepositoryLfsPointers(selector);
+        }
+        catch (error) {
+            return { git, lfs: failedLfs(stepFailure(error, 'lfs-pointer-scan-failed', signal)) };
+        }
+        return { git, lfs: await giteaLfsPresence(sourceArg, pointers) };
+    }
+    finally {
+        signal?.removeEventListener('abort', abort);
+        await manager.stop().catch(() => undefined);
+        await plugins.fs.rm(directory, { recursive: true, force: true });
+    }
+};
+const measureRefsAndObjects = async (managerArg, selectorArg, signalArg) => {
+    const counts = { branches: 0, tags: 0, pullRequestRefs: 0, otherRefs: 0 };
+    let refsFailure = null;
+    try {
+        let cursor;
+        do {
+            const page = await managerArg.listRefs({ ...selectorArg, cursor });
+            // Nothing writes to the private mirror, so a changed inventory is a failure.
+            if (page.status === 'stale')
+                throw new validation.ForgeInventoryError('git-refs-changed');
+            for (const ref of page.refs) {
+                if (ref.name.startsWith('refs/heads/'))
+                    counts.branches++;
+                else if (ref.name.startsWith('refs/tags/'))
+                    counts.tags++;
+                else if (ref.name.startsWith('refs/pull/'))
+                    counts.pullRequestRefs++;
+                else
+                    counts.otherRefs++;
+            }
+            cursor = page.pagination.status === 'more' ? page.pagination.cursor : undefined;
+        } while (cursor !== undefined);
+    }
+    catch (error) {
+        refsFailure = stepFailure(error, 'git-refs-failed', signalArg);
+    }
+    const refs = (valueArg) => refsFailure === null ? complete(valueArg) : partial(0, refsFailure);
+    let objects;
+    let objectBytes;
+    try {
+        const size = await managerArg.getRepositorySize(selectorArg);
+        objects = complete(size.objectCount);
+        objectBytes = complete(size.objectBytes);
+    }
+    catch (error) {
+        objects = objectBytes = partial(0, stepFailure(error, 'git-size-failed', signalArg));
+    }
+    return {
+        branches: refs(counts.branches), tags: refs(counts.tags), pullRequestRefs: refs(counts.pullRequestRefs), otherRefs: refs(counts.otherRefs),
+        objects, objectBytes,
+    };
+};
+/**
+ * Asks Gitea's LFS batch API, as a `download`, which referenced objects it
+ * holds: a held object answers with a download action, a missing one with
+ * error 404. Actions, their URLs and headers are never retained.
+ */
+export const giteaLfsPresence = async (sourceArg, pointersArg) => {
+    const url = new URL(`${sourceArg.baseUrl}/${encodeURIComponent(sourceArg.owner)}/${encodeURIComponent(sourceArg.name)}.git/info/lfs/objects/batch`);
+    let held = 0n;
+    let heldBytes = 0n;
+    let missing = 0n;
+    for (let index = 0; index < pointersArg.length; index += lfsBatchSize) {
+        const chunk = pointersArg.slice(index, index + lfsBatchSize);
+        try {
+            const response = await sourceArg.lfsClient.request(url, {
+                signal: sourceArg.signal,
+                mediaType: lfsMediaType,
+                json: { operation: 'download', transfers: ['basic'], objects: chunk.map((pointerArg) => ({ oid: pointerArg.oid, size: pointerArg.sizeBytes })) },
+            });
+            const objects = validation.record(response.body).objects;
+            if (!Array.isArray(objects) || objects.length !== chunk.length)
+                throw new validation.ForgeInventoryError('invalid-lfs-batch');
+            const requested = new Map(chunk.map((pointerArg) => [pointerArg.oid, pointerArg.sizeBytes]));
+            for (const objectArg of objects) {
+                const object = validation.record(objectArg);
+                const size = typeof object.oid === 'string' ? requested.get(object.oid) : undefined;
+                if (size === undefined || object.size !== size)
+                    throw new validation.ForgeInventoryError('invalid-lfs-batch');
+                requested.delete(object.oid);
+                const download = object.actions === undefined || object.actions === null ? undefined : validation.record(object.actions).download;
+                if (download !== undefined && download !== null && object.error === undefined) {
+                    held++;
+                    heldBytes += BigInt(size);
+                }
+                else if (object.error !== undefined && validation.record(object.error).code === 404) {
+                    missing++;
+                }
+                else {
+                    // A size that disagrees with the stored object answers 422.
+                    throw new validation.ForgeInventoryError('lfs-object-unavailable');
+                }
+            }
+        }
+        catch (error) {
+            const failure = stepFailure(error, 'lfs-batch-failed', sourceArg.signal);
+            return { objects: partial(held, failure), bytes: partial(heldBytes, failure), missingObjects: partial(missing, failure) };
+        }
+    }
+    return { objects: complete(held), bytes: complete(heldBytes), missingObjects: complete(missing) };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"giteasourceinventory.git.js","sourceRoot":"","sources":["../ts/giteasourceinventory.git.ts"],"names":[],"mappings":"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"}

package/dist_ts/plugins.d.ts

@@ -1,7 +1,9 @@
 import type * as fossInterfaces from '@foss.global/interfaces';
 import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
 import * as https from 'node:https';
-export { crypto, https };
+import * as path from 'node:path';
+export { crypto, fs, https, path };
 import * as interfaces from './interfaces/index.js';
 export { interfaces, };
 import * as lik from '@push.rocks/lik';
@@ -15,4 +17,5 @@ export type TGitManagerTreeEntry = import('@foss.global/gitmanager').IGitManager
 export type TGitManagerTag = import('@foss.global/gitmanager').IGitManagerTag;
 export type TGitManagerDiff = import('@foss.global/gitmanager').IGitManagerDiff;
 export declare const getSmartnpm: () => Promise<typeof import("@push.rocks/smartnpm")>;
+export declare const getGitManager: () => Promise<typeof import("@foss.global/gitmanager")>;
 export { smarttime, lik, };

package/dist_ts/plugins.js

@@ -1,6 +1,8 @@
 import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
 import * as https from 'node:https';
-export { crypto, https };
+import * as path from 'node:path';
+export { crypto, fs, https, path };
 // module
 import * as interfaces from './interfaces/index.js';
 export { interfaces, };
@@ -8,5 +10,6 @@ export { interfaces, };
 import * as lik from '@push.rocks/lik';
 import * as smarttime from '@push.rocks/smarttime';
 export const getSmartnpm = async () => import('@push.rocks/smartnpm');
+export const getGitManager = async () => import('@foss.global/gitmanager');
 export { smarttime, lik, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEtBQUssTUFBTSxZQUFZLENBQUM7QUFDcEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQztBQUV6QixTQUFTO0FBQ1QsT0FBTyxLQUFLLFVBQVUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEVBQ0wsVUFBVSxHQUNYLENBQUE7QUFFRCxjQUFjO0FBQ2QsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBV25ELE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxLQUFLLElBQUksRUFBRSxDQUFDLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0FBRXRFLE9BQU8sRUFDTCxTQUFTLEVBQ1QsR0FBRyxHQUNKLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssS0FBSyxNQUFNLFlBQVksQ0FBQztBQUNwQyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFbkMsU0FBUztBQUNULE9BQU8sS0FBSyxVQUFVLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsT0FBTyxFQUNMLFVBQVUsR0FDWCxDQUFBO0FBRUQsY0FBYztBQUNkLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQVduRCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsS0FBSyxJQUFJLEVBQUUsQ0FBQyxNQUFNLENBQUMsc0JBQXNCLENBQUMsQ0FBQztBQUN0RSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsS0FBSyxJQUFJLEVBQUUsQ0FBQyxNQUFNLENBQUMseUJBQXlCLENBQUMsQ0FBQztBQUUzRSxPQUFPLEVBQ0wsU0FBUyxFQUNULEdBQUcsR0FDSixDQUFBIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foss.global/codefeed",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "private": false,
   "description": "The @foss.global/codefeed module generates commit/activity feeds from forge providers including Gitea and GitManager.",
   "exports": {
@@ -11,7 +11,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@foss.global/forgefixtures": "^0.3.0",
+    "@foss.global/forgefixtures": "^0.3.1",
     "@git.zone/tsbuild": "^6.0.2",
     "@git.zone/tsbundle": "^3.2.1",
     "@git.zone/tsrun": "^3.0.3",
@@ -20,8 +20,8 @@
     "@types/node": "^26.6.4"
   },
   "dependencies": {
-    "@foss.global/gitmanager": "^2.1.0",
-    "@foss.global/interfaces": "^1.1.0",
+    "@foss.global/gitmanager": "^2.3.0",
+    "@foss.global/interfaces": "^2.0.0",
     "@push.rocks/lik": "^6.4.4",
     "@push.rocks/smartnpm": "^2.1.3",
     "@push.rocks/smarttime": "^5.0.1"

package/readme.md

@@ -80,7 +80,7 @@ The implementation has synthetic protocol fixtures based on the [Gitea 1.24.7 AP
 
 ### Authenticated Gitea source inventory
 
-`GiteaSourceInventory` measures a whole Gitea instance before its one-time migration, read with a site administrator's token. It returns the `IForgeSourceInventory` contract from `@foss.global/interfaces`: per-instance, per-owner and per-repository counts with totals, where every measure is `complete`, `partial` (attempted, did not finish) or `notMeasured` (not attempted). The inventory is complete only when discovery finished and every measure is complete; otherwise `inventoryComplete` is false and `incompleteReasons` names each gap. It only sends GET requests.
+`GiteaSourceInventory` measures a whole Gitea instance before its one-time migration, read with a site administrator's token. It returns the `IForgeSourceInventory` contract from `@foss.global/interfaces`: per-instance, per-owner and per-repository counts with totals, where every measure is `complete`, `partial` (attempted, did not finish) or `notMeasured` (not attempted). The inventory is complete only when discovery finished and every measure is complete; otherwise `inventoryComplete` is false and `incompleteReasons` names each gap. It never writes to the forge: it sends REST GET requests, clones each repository with Git, and asks the LFS batch API, as a `download`, which objects Gitea holds.
 
 ```ts
 import { GiteaSourceInventory, composeGiteaSourceInventory } from '@foss.global/codefeed';
@@ -89,7 +89,8 @@ const reader = new GiteaSourceInventory({
   instanceId: 'code-foss-global',
   baseUrl: 'https://gitea.example.com', // HTTPS only
   token: siteAdminToken, // read it from a file; never pass it on a command line
-  // caCertificates: [privateCaPem], pageSize: 50, maxPages: 10_000, requestTimeoutMs: 60_000, maxResponseBytes: 16 * 1024 * 1024,
+  gitWorkDir: '/var/lib/inventory/mirrors', // absolute, private; holds one temporary mirror per repository in flight
+  // caCertificates: [privateCaPem], gitTimeoutMs: 30 * 60 * 1000, pageSize: 50, maxPages: 10_000, requestTimeoutMs: 60_000, maxResponseBytes: 16 * 1024 * 1024,
 });
 
 const discovery = await reader.discover(); // rejects with `reader-not-site-admin` for other tokens
@@ -102,12 +103,13 @@ const inventory = composeGiteaSourceInventory(discovery, results, [{ package: '@
 
 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.
 
-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, issues, pull requests, comments, reviews, review comments, labels, milestones, reactions and attachments; releases including drafts, assets and asset bytes; wiki pages; collaborators, team grants, deploy keys, 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; releases including drafts, assets and asset bytes; wiki pages; collaborators, team grants, deploy keys, 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.
 
 Secrets are counted, never named: the report carries no tokens, Actions secret or variable values or names, webhook secrets or mirror remote URLs. Reasons are adapter codes or fixed text, never response bodies or URLs. Gitea has no read that lists user-scoped Actions secrets; that is listed in `limitations`, since they are reissued. User-scoped webhooks, variables and runners are read as that user through the `Sudo` header.
 
+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 travel as Basic credentials outside the URL, the Git command line and Git configuration; the private CA list applies to the clone as well. 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:
-- LFS objects are `notMeasured`: Gitea's API does not list them.
 - 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.
 
 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.
@@ -271,7 +273,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, 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, a Git-level one against a local HTTPS Git, LFS batch and REST 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).
 
 Run tests: