@foss.global/codefeed 4.1.0 → 4.3.0

package/dist_ts/forgeinventory.transfer.d.ts

@@ -0,0 +1,75 @@
+import * as plugins from './plugins.js';
+import * as validation from './forgeinventory.validation.js';
+/**
+ * Reads and drops at most 64 KiB of a response body that carries nothing the
+ * caller uses, so its connection can be reused; a longer or failing body is
+ * discarded with its connection.
+ */
+export declare const discardBody: (bodyArg: AsyncIterable<Uint8Array> | null) => Promise<void>;
+export interface ITransferBoundsOptions {
+    /** Wall-clock limit of the whole transfer. */
+    limitMs: number;
+    /** Longest gap between two chunks of a watched source. */
+    idleMs: number;
+    /** The code a passed wall-clock or idle limit fails with. */
+    timedOutCode: string;
+    /** The code a watched source that goes on after the transfer ended fails with. */
+    failedCode: string;
+}
+export interface ITransferBounds {
+    /** Aborts once the caller aborts, a limit passes or the transfer ends. */
+    signal: AbortSignal;
+    /** Ends the transfer: clears its timers and aborts `signal`. Idempotent. */
+    end: () => void;
+    /**
+     * The error the transfer fails with: the reason that ended it (`request-aborted`
+     * or the timeout code), else `errorArg` when it is a `ForgeInventoryError`,
+     * else `fallbackArg`.
+     */
+    failure: (errorArg: unknown, fallbackArg: string) => validation.ForgeInventoryError;
+    /** Runs one step of the transfer; it rejects as soon as the transfer ends, even if the step does not. */
+    run: <T>(stepArg: () => Promise<T>) => Promise<T>;
+    /** Re-arms the idle limit, before a step that waits on the network without a watched source. */
+    touch: () => void;
+    /** Passes chunks on and re-arms the idle limit on each one. */
+    watch: (sourceArg: AsyncIterable<Uint8Array>) => AsyncGenerator<Uint8Array, void, undefined>;
+}
+/**
+ * The bounds of one streamed transfer: the caller's signal, a wall-clock limit
+ * and an idle limit that `watch` re-arms on every chunk. Whichever ends it
+ * first decides the failure code. Every transfer must be ended with `end`.
+ */
+export declare const createTransferBounds: (signalArg: AbortSignal | undefined, optionsArg: ITransferBoundsOptions) => ITransferBounds;
+export interface IHeldBackCodes {
+    /** A chunk that is not a `Uint8Array`. */
+    invalidChunk: string;
+    /** More bytes than the declared size. */
+    overrun: string;
+    /** Fewer bytes than the declared size. */
+    short: string;
+}
+export interface IHeldBackChecks {
+    /** Sees every non-empty chunk in order, before it is passed on. */
+    inspect?: (chunkArg: Uint8Array) => void;
+    /** Runs once exactly `size` bytes have arrived, before the last chunk is passed on; a rejection keeps it back. */
+    complete?: () => void | Promise<void>;
+}
+/**
+ * Passes the bytes of `sourceArg` on while it counts them. The last chunk is
+ * held back until the source has ended with exactly `sizeArg` bytes and
+ * `checksArg.complete` has passed, so a consumer never receives a complete
+ * body that is wrong; otherwise it throws `codesArg.overrun` as soon as the
+ * size is exceeded, `codesArg.short` when the source ends early, or what
+ * `complete` threw.
+ */
+export declare function heldBackChunks(sourceArg: AsyncIterable<Uint8Array>, sizeArg: number, codesArg: IHeldBackCodes, checksArg?: IHeldBackChecks): AsyncGenerator<Uint8Array, void, undefined>;
+/**
+ * The readable stream of one transfer's bytes. It pulls `chunksArg` with
+ * backpressure and ends `boundsArg` and calls `onEndArg` as soon as it is
+ * destroyed, also while a pull is pending: ending the bounds aborts the
+ * request, which closes its connection, and the pending pull's result is
+ * dropped. (`Readable.from` waits for a pending pull before it finishes a
+ * destroy, so a stalled body would keep its connection until the idle limit.)
+ * The stream errors with what `chunksArg` throws.
+ */
+export declare const createTransferStream: (boundsArg: ITransferBounds, chunksArg: AsyncGenerator<Uint8Array, void, undefined>, onEndArg?: () => void) => InstanceType<typeof plugins.stream.Readable>;

package/dist_ts/forgeinventory.transfer.js

@@ -0,0 +1,174 @@
+import * as plugins from './plugins.js';
+import * as validation from './forgeinventory.validation.js';
+/** Response bytes read from an unused answer before the rest is discarded. */
+const maxDiscardedResponseBytes = 64 * 1024;
+/**
+ * Reads and drops at most 64 KiB of a response body that carries nothing the
+ * caller uses, so its connection can be reused; a longer or failing body is
+ * discarded with its connection.
+ */
+export const discardBody = async (bodyArg) => {
+    if (!bodyArg)
+        return;
+    const chunks = bodyArg[Symbol.asyncIterator]();
+    let bytes = 0;
+    try {
+        while (bytes <= maxDiscardedResponseBytes) {
+            const result = await chunks.next();
+            if (result.done)
+                return;
+            bytes += result.value.byteLength;
+        }
+    }
+    catch {
+        // The status already decided the outcome.
+    }
+    finally {
+        try {
+            await chunks.return?.();
+        }
+        catch { /* The connection is discarded. */ }
+    }
+};
+/**
+ * The bounds of one streamed transfer: the caller's signal, a wall-clock limit
+ * and an idle limit that `watch` re-arms on every chunk. Whichever ends it
+ * first decides the failure code. Every transfer must be ended with `end`.
+ */
+export const createTransferBounds = (signalArg, optionsArg) => {
+    const controller = new AbortController();
+    let reason = null;
+    const stop = (reasonArg) => {
+        reason ??= reasonArg;
+        controller.abort();
+    };
+    const abort = () => stop('request-aborted');
+    if (signalArg?.aborted)
+        abort();
+    signalArg?.addEventListener('abort', abort, { once: true });
+    const deadline = setTimeout(() => stop(optionsArg.timedOutCode), optionsArg.limitMs);
+    let idle;
+    const rearm = () => {
+        clearTimeout(idle);
+        if (!controller.signal.aborted)
+            idle = setTimeout(() => stop(optionsArg.timedOutCode), optionsArg.idleMs);
+    };
+    rearm();
+    const end = () => {
+        clearTimeout(deadline);
+        clearTimeout(idle);
+        signalArg?.removeEventListener('abort', abort);
+        stop('transfer-ended');
+    };
+    const failure = (errorArg, fallbackArg) => {
+        if (reason !== null && reason !== 'transfer-ended')
+            return new validation.ForgeInventoryError(reason);
+        return errorArg instanceof validation.ForgeInventoryError ? errorArg : new validation.ForgeInventoryError(fallbackArg);
+    };
+    return {
+        signal: controller.signal,
+        end,
+        failure,
+        touch: rearm,
+        run: async (stepArg) => {
+            if (controller.signal.aborted)
+                throw failure(undefined, 'request-aborted');
+            let onAbort;
+            const aborted = new Promise((_resolve, reject) => {
+                onAbort = () => reject(failure(undefined, 'request-aborted'));
+                controller.signal.addEventListener('abort', onAbort, { once: true });
+            });
+            try {
+                return await Promise.race([stepArg(), aborted]);
+            }
+            finally {
+                controller.signal.removeEventListener('abort', onAbort);
+            }
+        },
+        watch: async function* (sourceArg) {
+            for await (const chunk of sourceArg) {
+                if (controller.signal.aborted)
+                    throw failure(undefined, optionsArg.failedCode);
+                rearm();
+                yield chunk;
+            }
+        },
+    };
+};
+/**
+ * Passes the bytes of `sourceArg` on while it counts them. The last chunk is
+ * held back until the source has ended with exactly `sizeArg` bytes and
+ * `checksArg.complete` has passed, so a consumer never receives a complete
+ * body that is wrong; otherwise it throws `codesArg.overrun` as soon as the
+ * size is exceeded, `codesArg.short` when the source ends early, or what
+ * `complete` threw.
+ */
+export async function* heldBackChunks(sourceArg, sizeArg, codesArg, checksArg = {}) {
+    let bytes = 0;
+    let held = null;
+    for await (const chunk of sourceArg) {
+        if (!(chunk instanceof Uint8Array))
+            throw new validation.ForgeInventoryError(codesArg.invalidChunk);
+        if (chunk.byteLength === 0)
+            continue;
+        bytes += chunk.byteLength;
+        if (bytes > sizeArg)
+            throw new validation.ForgeInventoryError(codesArg.overrun);
+        checksArg.inspect?.(chunk);
+        if (held)
+            yield held;
+        held = chunk;
+    }
+    if (bytes !== sizeArg)
+        throw new validation.ForgeInventoryError(codesArg.short);
+    await checksArg.complete?.();
+    if (held)
+        yield held;
+}
+/**
+ * The readable stream of one transfer's bytes. It pulls `chunksArg` with
+ * backpressure and ends `boundsArg` and calls `onEndArg` as soon as it is
+ * destroyed, also while a pull is pending: ending the bounds aborts the
+ * request, which closes its connection, and the pending pull's result is
+ * dropped. (`Readable.from` waits for a pending pull before it finishes a
+ * destroy, so a stalled body would keep its connection until the idle limit.)
+ * The stream errors with what `chunksArg` throws.
+ */
+export const createTransferStream = (boundsArg, chunksArg, onEndArg) => {
+    let pulling = false;
+    const stream = new plugins.stream.Readable({
+        read() {
+            if (pulling)
+                return;
+            pulling = true;
+            void (async () => {
+                try {
+                    while (!stream.destroyed) {
+                        const result = await chunksArg.next();
+                        if (stream.destroyed)
+                            return;
+                        if (result.done)
+                            return void stream.push(null);
+                        if (!stream.push(result.value))
+                            return;
+                    }
+                }
+                catch (error) {
+                    stream.destroy(error);
+                }
+                finally {
+                    pulling = false;
+                }
+            })();
+        },
+        destroy(errorArg, callbackArg) {
+            boundsArg.end();
+            onEndArg?.();
+            // Runs the generator's cleanup once a pending pull has settled; nothing waits for it.
+            chunksArg.return(undefined).catch(() => undefined);
+            callbackArg(errorArg);
+        },
+    });
+    return stream;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/giteasourceinventory.git.d.ts

@@ -3,11 +3,16 @@ import type { ForgeRequestClient } from './forgeinventory.client.js';
 type IGitCounts = Omit<plugins.fossInterfaces.data.IForgeSourceGitCounts, 'reportedSizeKiB'>;
 type ILfsCounts = plugins.fossInterfaces.data.IForgeSourceLfsCounts;
 type IHead = plugins.fossInterfaces.data.IForgeSourceRepositoryHead;
-/** The Git level measure of one repository; `head` is null when the mirror's refs could not be read. */
+type IRefDigests = plugins.fossInterfaces.data.IForgeSourceRefDigests;
+/**
+ * The Git level measure of one repository; `head` and `refDigests` are null
+ * when the mirror's refs could not be read.
+ */
 export interface IGiteaMirrorMeasure {
     git: IGitCounts;
     lfs: ILfsCounts;
     head: IHead | null;
+    refDigests: IRefDigests | null;
 }
 export interface IGiteaMirrorSource {
     /** Instance root without a trailing slash. */
@@ -78,6 +83,16 @@ export declare const giteaCloneUrl: (baseUrlArg: string, ownerArg: string, nameA
  * repository too large for it fails with `git-workdir-too-small`.
  */
 export declare const measureGiteaMirror: (sourceArg: IGiteaMirrorSource) => Promise<IGiteaMirrorMeasure>;
+/**
+ * Reads GitManager's ref inventory digest and ref count of each namespace in
+ * `refDigestPrefixes`: one `listRefs` page of a single ref per prefix, whose
+ * digest and count cover the complete selection. Resolves with null when any
+ * read fails, never with a partial set.
+ */
+export declare const readRefDigests: (managerArg: Pick<plugins.TGitManager, 'listRefs'>, selectorArg: {
+    org: string;
+    repo: string;
+}) => Promise<IRefDigests | null>;
 /**
  * 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

package/dist_ts/giteasourceinventory.git.js

@@ -167,7 +167,7 @@ export const measureGiteaMirror = async (sourceArg) => {
     }
     catch (error) {
         const failure = stepFailure(error, 'git-workdir-failed', signal);
-        return { git: failedGit(failure), lfs: failedLfs(failure), head: null };
+        return { git: failedGit(failure), lfs: failedLfs(failure), head: null, refDigests: null };
     }
     try {
         return await measureReservedMirror(sourceArg);
@@ -184,7 +184,7 @@ const measureReservedMirror = async (sourceArg) => {
         directory = await plugins.fs.mkdtemp(plugins.path.join(sourceArg.workDir, 'mirror-'));
     }
     catch {
-        return { git: failedGit('git-workdir-failed'), lfs: failedLfs('git-workdir-failed'), head: null };
+        return { git: failedGit('git-workdir-failed'), lfs: failedLfs('git-workdir-failed'), head: null, refDigests: null };
     }
     const manager = new GitManager({ dataDir: directory });
     // The engine serves this measurement alone; stopping it ends the ref, object
@@ -207,17 +207,17 @@ const measureReservedMirror = async (sourceArg) => {
         }
         catch (error) {
             const failure = stepFailure(error, 'git-mirror-failed', signal);
-            return { git: failedGit(failure), lfs: failedLfs(failure), head: null };
+            return { git: failedGit(failure), lfs: failedLfs(failure), head: null, refDigests: null };
         }
-        const { git, head } = await measureRefsAndObjects(manager, selector, signal);
+        const { git, head, refDigests } = 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)), head };
+            return { git, lfs: failedLfs(stepFailure(error, 'lfs-pointer-scan-failed', signal)), head, refDigests };
         }
-        return { git, lfs: await giteaLfsPresence(sourceArg, pointers), head };
+        return { git, lfs: await giteaLfsPresence(sourceArg, pointers), head, refDigests };
     }
     finally {
         signal?.removeEventListener('abort', abort);
@@ -225,6 +225,30 @@ const measureReservedMirror = async (sourceArg) => {
         await plugins.fs.rm(directory, { recursive: true, force: true });
     }
 };
+/** The ref namespaces an import carries, each recorded with its own digest. */
+const refDigestPrefixes = { heads: 'refs/heads/', tags: 'refs/tags/', notes: 'refs/notes/' };
+/**
+ * Reads GitManager's ref inventory digest and ref count of each namespace in
+ * `refDigestPrefixes`: one `listRefs` page of a single ref per prefix, whose
+ * digest and count cover the complete selection. Resolves with null when any
+ * read fails, never with a partial set.
+ */
+export const readRefDigests = async (managerArg, selectorArg) => {
+    const read = async (prefixArg) => {
+        const page = await managerArg.listRefs({ ...selectorArg, prefixes: [prefixArg], limit: 1 });
+        // Only a cursor can be stale, and a first page sends none.
+        return page.status === 'page' ? { inventoryDigest: page.inventoryDigest, refCount: page.refCount } : null;
+    };
+    try {
+        const heads = await read(refDigestPrefixes.heads);
+        const tags = await read(refDigestPrefixes.tags);
+        const notes = await read(refDigestPrefixes.notes);
+        return heads && tags && notes ? { heads, tags, notes } : null;
+    }
+    catch {
+        return null;
+    }
+};
 const measureRefsAndObjects = async (managerArg, selectorArg, signalArg) => {
     const counts = { branches: 0, tags: 0, pullRequestRefs: 0, otherRefs: 0 };
     let head = null;
@@ -256,6 +280,8 @@ const measureRefsAndObjects = async (managerArg, selectorArg, signalArg) => {
         refsFailure = stepFailure(error, 'git-refs-failed', signalArg);
     }
     const refs = (valueArg) => refsFailure === null ? complete(valueArg) : partial(0, refsFailure);
+    // Nothing writes to the private mirror, so the digests describe the refs just counted.
+    const refDigests = refsFailure === null ? await readRefDigests(managerArg, selectorArg) : null;
     let objects;
     let objectBytes;
     try {
@@ -272,6 +298,7 @@ const measureRefsAndObjects = async (managerArg, selectorArg, signalArg) => {
             objects, objectBytes,
         },
         head,
+        refDigests,
     };
 };
 /**
@@ -323,4 +350,4 @@ export const giteaLfsPresence = async (sourceArg, pointersArg) => {
     }
     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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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"giteasourceinventory.git.js","sourceRoot":"","sources":["../ts/giteasourceinventory.git.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foss.global/codefeed",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "private": false,
   "description": "The @foss.global/codefeed module generates commit/activity feeds from forge providers including Gitea and GitManager.",
   "exports": {
@@ -11,17 +11,14 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@foss.global/forgefixtures": "^0.3.1",
-    "@git.zone/tsbuild": "^6.0.2",
-    "@git.zone/tsbundle": "^3.3.0",
-    "@git.zone/tsrun": "^3.0.3",
-    "@git.zone/tstest": "^8.0.0",
+    "@foss.global/forgefixtures": "^0.5.1",
+    "@git.zone/tsrepo": "^2.0.0",
     "@push.rocks/qenv": "^8.2.1",
-    "@types/node": "^26.6.4"
+    "@types/node": "^26.6.6"
   },
   "dependencies": {
     "@foss.global/gitmanager": "^2.4.0",
-    "@foss.global/interfaces": "^2.6.0",
+    "@foss.global/interfaces": "^2.8.0",
     "@push.rocks/lik": "^6.4.4",
     "@push.rocks/smartnpm": "^2.1.3",
     "@push.rocks/smarttime": "^5.0.1"
@@ -62,8 +59,8 @@
     "version control"
   ],
   "scripts": {
-    "test": "(tstest test/ --verbose)",
-    "build": "(tsbuild tsfolders --web --allowimplicitany)",
-    "buildDocs": "(tsdoc)"
+    "test": "(tsrepo test test/ --verbose)",
+    "build": "(tsrepo build tsfolders --web --allowimplicitany)",
+    "buildDocs": "(tsrepo docs)"
   }
 }

package/readme.md

@@ -109,9 +109,11 @@ Discovery records each repository's Gitea `id` as a canonical decimal string, an
 
 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.
 
+Beyond counts, each repository keeps records of what the migration recreates. `releaseRecords` lists every release, drafts and prereleases included, sorted by numeric id: tag name, target commitish, name, body, the draft and prerelease flags, created and published times as Gitea reports them (a draft reports its creation time as published, and its tag does not exist as a Git ref yet), 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.
+
 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 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 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.
+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.
@@ -120,7 +122,7 @@ Listings page until an empty page or the `x-total-count` total is reached. A tot
 
 ### Gitea source transfer
 
-`GiteaSourceTransfer` reads one repository's Git data and LFS objects 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.
+`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.
 
 ```ts
 import { GitManager } from '@foss.global/gitmanager';
@@ -130,7 +132,8 @@ const source = new GiteaSourceTransfer({
   baseUrl: 'https://gitea.example.com', // HTTPS only
   login: readerLogin,
   token: readerToken, // read it from a file; never pass it on a command line
-  // caCertificates: [privateCaPem], gitTimeoutMs: 30 * 60 * 1000, requestTimeoutMs: 60_000, maxResponseBytes: 16 * 1024 * 1024, lfsTransferTimeoutMs: 30 * 60 * 1000,
+  // caCertificates: [privateCaPem], gitTimeoutMs: 30 * 60 * 1000, requestTimeoutMs: 60_000, maxResponseBytes: 16 * 1024 * 1024,
+  // lfsTransferTimeoutMs: 30 * 60 * 1000, releaseAssetTimeoutMs: 30 * 60 * 1000,
 });
 
 // A started GitManager rooted in the caller's own scratch space; codefeed creates no scratch roots.
@@ -147,6 +150,10 @@ if (download.status === 'missing') {
 } else {
   await pipeline(download.stream, destination); // errors unless the bytes are exactly the object
 }
+
+// A release asset as the inventory recorded it: { id, uuid, name, size } from releaseRecords[].assets[].
+const asset = await source.downloadReleaseAsset({ owner: 'team', name: 'app', id: '11' }, release.id, recordedAsset, { signal });
+await pipeline(asset.stream, destination); // errors unless exactly `size` bytes of the recorded asset arrived
 ```
 
 A source repository is named by `owner`, `name` and its Gitea repository `id`, a canonical decimal string as the inventory records it; anything else rejects with `invalid-repository`. Git and the LFS API reach a repository only by name, and a name can move to another repository between two reads: Gitea answers a renamed repository's old path with a redirect, and a new repository can take the old name. Every source read is therefore bracketed by an identity read of `GET /api/v1/repositories/{id}`, which must still name `owner/name` (compared case-insensitively, as Gitea does). A repository that was renamed, or whose name now belongs to another repository, rejects with `repository-identity-changed`; a deleted one rejects with `http-404`. A transfer that fails is explained the same way when the identity read shows one of those two causes.
@@ -155,7 +162,9 @@ A source repository is named by `owner`, `name` and its Gitea repository `id`, a
 
 While the import runs, GitManager holds `target`: writes to it, such as `initBareRepository`, `restoreRepositoryBundle`, `setDefaultBranch` or a Smart HTTP push, fail with a `GitManagerError` whose code is `repositoryBusy`, and a second import into the same `target` is refused at once (codefeed rejects it with `git-mirror-failed`). Reads, of `target` as of other repositories, proceed.
 
-`downloadLfsObject` sends one batch `download` request with the reader's Basic credentials, then a GET of the action's href with the action's headers only, and then reads the identity; when that read rejects, the stream is destroyed and the call rejects with its code. A missing object resolves as `{ status: 'missing' }`, so a caller can list the missing oids; any other object error rejects with `lfs-object-error-<code>`, such as `lfs-object-error-422` for a size Gitea disagrees with. The returned stream never holds the whole object: it counts and hashes the bytes as they pass and holds back the last chunk until the body ended with exactly `size` bytes whose SHA-256 is `oid`. Otherwise it errors with `lfs-size-overrun`, `lfs-short-body` or `lfs-digest-mismatch`; a `content-length` other than `size` rejects with `lfs-size-mismatch` before streaming. An abort errors it with `request-aborted`, a transfer longer than `lfsTransferTimeoutMs` or idle for `requestTimeoutMs` with `lfs-transfer-timed-out`. Destroying the stream ends the download.
+`downloadLfsObject` sends one batch `download` request with the reader's Basic credentials, then a GET of the action's href with the action's headers only, and then reads the identity; when that read rejects, the stream is destroyed and the call rejects with its code. A missing object resolves as `{ status: 'missing' }`, so a caller can list the missing oids; any other object error rejects with `lfs-object-error-<code>`, such as `lfs-object-error-422` for a size Gitea disagrees with. The returned stream never holds the whole object: it counts and hashes the bytes as they pass and holds back the last chunk until the body ended with exactly `size` bytes whose SHA-256 is `oid`. Otherwise it errors with `lfs-size-overrun`, `lfs-short-body` or `lfs-digest-mismatch`; a `content-length` other than `size` rejects with `lfs-size-mismatch` before streaming. An abort errors it with `request-aborted`, a transfer longer than `lfsTransferTimeoutMs` or idle for `requestTimeoutMs` with `lfs-transfer-timed-out`. Destroying the stream ends the download. The stream fails internally with `lfs-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.
+
+`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.
 
 ### Git LFS batch client
 
@@ -176,7 +185,7 @@ const download = await lfs.download({ oid, size }, { signal }); // as for downlo
 lfs.close(); // optional: idle pooled connections close on their own
 ```
 
-- `upload` sends one batch `upload` request per `batchSize` objects (at most 100). An object without an `upload` action is already present; for each other one it opens the source, PUTs exactly `size` bytes with the action's headers and `Content-Length: size`, and then calls the `verify` action when the server sent one. The bytes are hashed while they stream and the last chunk is held back, so a source that is not the object is never sent complete (`lfs-size-overrun`, `lfs-short-body`, `lfs-digest-mismatch`). Any object error rejects with `lfs-object-error-<code>`.
+- `upload` sends one batch `upload` request per `batchSize` objects (at most 100). An object without an `upload` action is already present; for each other one it opens the source, PUTs exactly `size` bytes with the action's headers and `Content-Length: size`, and then calls the `verify` action when the server sent one. The bytes are hashed while they stream and the last chunk is held back, so a source that is not the object is never sent complete (`lfs-size-overrun`, `lfs-short-body`, `lfs-digest-mismatch`). Any object error rejects with `lfs-object-error-<code>`. A source that still yields bytes after its upload has ended fails internally with `lfs-transfer-failed`; that happens only once the upload has settled, so the caller does not see it.
 - Action expiry: `expires_in` (whole seconds after the batch answer arrived) is preferred over `expires_at` (RFC 3339), as the batch API specifies; like the git-lfs client, an `expires_in` of 0 and Go's zero time mean no expiry, and any other malformed value fails with `invalid-lfs-batch`. An upload, verify or download action is used only while it stays valid for the expiry margin, 30 s or `requestTimeoutMs` when that is shorter. Objects are transferred one at a time after their batch answer, so a later object whose action would expire within the margin is asked for again in a batch of its own, once; when the fresh answer is again too short-lived the call fails with `lfs-action-expired`. A verify action that expires during its PUT is asked for the same way; a fresh answer without actions means the server holds the object.
 - `checkPresence` sends batch `download` requests and downloads nothing: a download action means `held`, error 404 `missing`. It uses no action, so expiry is validated but not enforced there.
 - The credential is sent only as the `Authorization` header of batch requests to the endpoint, never to action hrefs and never in a URL, error or result; hrefs get the action's headers only. Action headers may not set connection-level fields (`host`, `content-length`, `transfer-encoding` and similar).
@@ -347,7 +356,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 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).
+- 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).
 - 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: '4.1.0',
+  version: '4.3.0',
   description: 'The @foss.global/codefeed module generates commit/activity feeds from forge providers including Gitea and GitManager.'
 }