@foss.global/codefeed 1.11.0 → 1.12.0

package/changelog.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 2026-09-05 - 1.12.0
+
+### Features
+
+- add read-only forge inventory scanner for Gitea and GitLab (forge-inventory)
+  - Add ForgeInventoryAdapter and ForgeInventoryScanner exports for bounded repository and namespace observations.
+  - Validate provider payloads, cursors, URLs, response budgets, aborts, and rate-limit metrics without leaking tokens or response bodies.
+  - Document scanner usage and add protocol fixture tests for Gitea and GitLab inventory behavior.
+  - Update @foss.global/interfaces to ^0.12.0 for inventory DTO support.
+
+### Fixes
+
+- update package manager and development tooling dependencies (deps)
+  - Updated @git.zone/tsbundle to ^2.13.0
+  - Updated @git.zone/tsrun to ^2.0.6
+  - Updated @git.zone/tstest to ^4.0.0
+  - Updated @types/node to ^26.4.1
+  - Updated pnpm to 11.25.0
+- correct default tag workflow repository URL and remove release job (ci)
+  - Set the computed repository URL to include the code.foss.global host.
+  - Remove the tag-triggered npm publish release job from the default tags workflow.
+
+## 2026-07-21 - 1.11.1
+
+### Fixes
+
+- remove the unused `@push.rocks/smartxml` 1.x dependency so consumers no longer inherit declarations that are incompatible with current TypeScript libraries
+
 ## 2026-07-21 - 1.11.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@foss.global/codefeed',
-    version: '1.11.0',
+    version: '1.12.0',
     description: 'The @foss.global/codefeed module generates commit/activity feeds from forge providers including Gitea and GitManager.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHVIQUF1SDtDQUNySSxDQUFBIn0=

package/dist_ts/classes.forgeinventory.d.ts

@@ -0,0 +1,45 @@
+import * as plugins from './plugins.js';
+export { ForgeInventoryError } from './forgeinventory.validation.js';
+export interface IForgeInventoryOptions {
+    kind: 'gitea' | 'gitlab';
+    instanceId: string;
+    /** Instance root, including an optional deployment subpath. HTTPS is required. */
+    baseUrl: string;
+    /** Personal access token, retained only in this adapter's memory. */
+    token?: string;
+    pageSize?: number;
+    maxPages?: number;
+    requestTimeoutMs?: number;
+    maxResponseBytes?: number;
+}
+export interface IForgeInventoryRequest {
+    cursor?: string;
+    signal?: AbortSignal;
+    /** Optional lower response-body budget for this request. */
+    maxResponseBytes?: number;
+}
+export interface IForgeInventoryMetrics {
+    requests: number;
+    responseBytes: number;
+    rateLimitedRequests: number;
+}
+/** Read-only, caller-visible API observations. This adapter never claims admin completeness. */
+export declare class ForgeInventoryAdapter {
+    #private;
+    constructor(optionsArg: IForgeInventoryOptions);
+    get instance(): plugins.fossInterfaces.data.IForgeInventoryInstance;
+    get metrics(): IForgeInventoryMetrics;
+    observation(startedAt: string): plugins.fossInterfaces.data.IForgeInventoryObservation;
+    listRepositories(requestArg?: IForgeInventoryRequest): Promise<plugins.fossInterfaces.data.IForgeInventoryPage<plugins.fossInterfaces.data.IForgeInventoryRepository>>;
+    /** Organizations/groups only. User namespaces are not enumerated by these endpoints. */
+    listNamespaces(requestArg?: IForgeInventoryRequest): Promise<plugins.fossInterfaces.data.IForgeInventoryPage<plugins.fossInterfaces.data.IForgeInventoryNamespace>>;
+    private identity;
+    private namespace;
+    private repository;
+    private url;
+    private cursor;
+    private continuation;
+    private page;
+    private next;
+    private request;
+}

package/dist_ts/classes.forgeinventory.js

@@ -0,0 +1,318 @@
+import * as plugins from './plugins.js';
+import * as validation from './forgeinventory.validation.js';
+export { ForgeInventoryError } from './forgeinventory.validation.js';
+/** Read-only, caller-visible API observations. This adapter never claims admin completeness. */
+export class ForgeInventoryAdapter {
+    #options;
+    #cursorKey = plugins.crypto.randomBytes(32);
+    #metrics = { requests: 0, responseBytes: 0, rateLimitedRequests: 0 };
+    constructor(optionsArg) {
+        const baseUrl = validation.httpUrl(optionsArg.baseUrl);
+        if (!baseUrl || !baseUrl.startsWith('https:') || !optionsArg.instanceId.trim() ||
+            !['gitea', 'gitlab'].includes(optionsArg.kind) ||
+            (optionsArg.token !== undefined && (!optionsArg.token || /[\s\u0000-\u001f\u007f]/.test(optionsArg.token)))) {
+            throw new validation.ForgeInventoryError('invalid-options');
+        }
+        this.#options = {
+            ...optionsArg,
+            baseUrl: baseUrl.replace(/\/$/, ''),
+            pageSize: optionsArg.pageSize ?? 50,
+            maxPages: optionsArg.maxPages ?? 1000,
+            requestTimeoutMs: optionsArg.requestTimeoutMs ?? 30_000,
+            maxResponseBytes: optionsArg.maxResponseBytes ?? 8 * 1024 * 1024,
+        };
+        for (const [name, maximum] of [
+            ['pageSize', 100], ['maxPages', 100_000], ['requestTimeoutMs', 300_000], ['maxResponseBytes', 64 * 1024 * 1024],
+        ]) {
+            const value = this.#options[name];
+            if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+                throw new validation.ForgeInventoryError('invalid-limits');
+        }
+    }
+    get instance() {
+        return { instanceId: this.#options.instanceId, kind: this.#options.kind, version: null };
+    }
+    get metrics() { return { ...this.#metrics }; }
+    observation(startedAt) {
+        return {
+            startedAt, finishedAt: new Date().toISOString(),
+            access: this.#options.token ? 'callerVisible' : 'publicOnly', consistency: { status: 'live' },
+        };
+    }
+    listRepositories(requestArg = {}) {
+        return this.page('repositories', (item) => this.repository(item), requestArg);
+    }
+    /** Organizations/groups only. User namespaces are not enumerated by these endpoints. */
+    listNamespaces(requestArg = {}) {
+        return this.page('namespaces', (item) => this.namespace(item), requestArg);
+    }
+    identity(idNamespace, value) {
+        const objectId = validation.decimal(value);
+        if (objectId === '0')
+            throw new validation.ForgeInventoryError('invalid-identity');
+        return { status: 'identified', ref: { instanceId: this.#options.instanceId, idNamespace, objectId, parentObjectId: null } };
+    }
+    namespace(itemArg) {
+        const item = validation.record(itemArg);
+        if (this.#options.kind === 'gitea') {
+            const pathSegments = validation.segments(item.name);
+            if (pathSegments.length !== 1)
+                throw new validation.ForgeInventoryError('invalid-organization-path');
+            return {
+                identity: this.identity('gitea.user.id', item.id), kind: 'organization', parent: null,
+                location: { pathSegments, webUrl: null },
+                visibility: validation.visibility(item.visibility === 'limited' ? 'internal' : item.visibility),
+            };
+        }
+        return {
+            identity: this.identity('gitlab.group.id', item.id), kind: 'group',
+            parent: item.parent_id === null ? null : item.parent_id === undefined
+                ? { status: 'unresolved', reason: 'Parent group was not exposed.' }
+                : this.identity('gitlab.group.id', item.parent_id),
+            location: { pathSegments: validation.segments(item.full_path), webUrl: validation.httpUrl(item.web_url) },
+            visibility: validation.visibility(item.visibility),
+        };
+    }
+    repository(itemArg) {
+        const item = validation.record(itemArg);
+        if (this.#options.kind === 'gitea') {
+            const owner = validation.record(item.owner);
+            const pathSegments = [...validation.segments(owner.login), ...validation.segments(item.name)];
+            if (pathSegments.length !== 2)
+                throw new validation.ForgeInventoryError('invalid-repository-path');
+            const privateRepo = validation.optionalBoolean(item.private);
+            const internalRepo = validation.optionalBoolean(item.internal);
+            return {
+                identity: this.identity('gitea.repository.id', item.id), namespace: this.identity('gitea.user.id', owner.id),
+                location: { pathSegments, webUrl: validation.httpUrl(item.html_url) },
+                description: validation.optionalString(item.description),
+                visibility: privateRepo === true ? 'private' : internalRepo === true ? 'internal' : privateRepo === false && internalRepo === false ? 'public' : null,
+                archived: validation.optionalBoolean(item.archived), defaultBranch: validation.optionalString(item.default_branch),
+                httpCloneUrl: validation.httpUrl(item.clone_url), sshCloneUrl: validation.sshUrl(item.ssh_url),
+                gitSizeBytes: validation.unknownSize('Gitea size is not a separate Git byte measurement.'),
+            };
+        }
+        const namespace = validation.record(item.namespace);
+        if (namespace.kind !== 'group' && namespace.kind !== 'user')
+            throw new validation.ForgeInventoryError('invalid-namespace-kind');
+        return {
+            identity: this.identity('gitlab.project.id', item.id),
+            namespace: this.identity(namespace.kind === 'group' ? 'gitlab.group.id' : 'gitlab.namespace.id', namespace.id),
+            location: { pathSegments: validation.segments(item.path_with_namespace), webUrl: validation.httpUrl(item.web_url) },
+            description: validation.optionalString(item.description), visibility: validation.visibility(item.visibility),
+            archived: validation.optionalBoolean(item.archived), defaultBranch: validation.optionalString(item.default_branch),
+            httpCloneUrl: validation.httpUrl(item.http_url_to_repo), sshCloneUrl: validation.sshUrl(item.ssh_url_to_repo),
+            gitSizeBytes: validation.gitlabSize(item.statistics),
+        };
+    }
+    url(state) {
+        const gitea = this.#options.kind === 'gitea';
+        const endpoint = state.collection === 'repositories' ? (gitea ? 'repos/search' : 'projects') : (gitea ? 'orgs' : 'groups');
+        const url = new URL(`${this.#options.baseUrl}/api/${gitea ? 'v1' : 'v4'}/${endpoint}`);
+        url.searchParams.set(gitea ? 'limit' : 'per_page', String(this.#options.pageSize));
+        if (gitea) {
+            url.searchParams.set('page', String(state.page));
+            if (state.collection === 'repositories') {
+                url.searchParams.set('sort', 'id');
+                url.searchParams.set('order', 'asc');
+                url.searchParams.set('private', 'true');
+            }
+        }
+        else {
+            url.searchParams.set('order_by', 'id');
+            url.searchParams.set('sort', 'asc');
+            if (state.collection === 'repositories') {
+                url.searchParams.set('pagination', 'keyset');
+                url.searchParams.set('statistics', 'true');
+                if (state.after)
+                    url.searchParams.set('id_after', state.after);
+            }
+            else {
+                url.searchParams.set('all_available', 'true');
+                url.searchParams.set('page', String(state.page));
+            }
+        }
+        return url;
+    }
+    cursor(state) {
+        const payload = Buffer.from(JSON.stringify(state)).toString('base64url');
+        return `${payload}.${plugins.crypto.createHmac('sha256', this.#cursorKey).update(payload).digest('base64url')}`;
+    }
+    continuation(collection, cursor) {
+        if (cursor === undefined)
+            return { version: 1, collection, page: 1, after: null };
+        try {
+            if (cursor.length > 2048)
+                throw new Error();
+            const [payload, signature, extra] = cursor.split('.');
+            const expected = plugins.crypto.createHmac('sha256', this.#cursorKey).update(payload).digest('base64url');
+            if (extra !== undefined || !signature || signature.length !== expected.length ||
+                !plugins.crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected)))
+                throw new Error();
+            const state = JSON.parse(Buffer.from(payload, 'base64url').toString());
+            if (state.version !== 1 || state.collection !== collection || !Number.isSafeInteger(state.page) ||
+                state.page < 2 || state.page > this.#options.maxPages ||
+                (state.after !== null && validation.decimal(state.after) !== state.after))
+                throw new Error();
+            return state;
+        }
+        catch {
+            throw new validation.ForgeInventoryError('invalid-cursor');
+        }
+    }
+    async page(collection, map, requestArg) {
+        const state = this.continuation(collection, requestArg.cursor);
+        const startedAt = new Date().toISOString();
+        const url = this.url(state);
+        const { body, headers } = await this.request(url, requestArg);
+        let rows = body;
+        if (this.#options.kind === 'gitea' && collection === 'repositories') {
+            const envelope = validation.record(body);
+            if (envelope.ok !== true)
+                throw new validation.ForgeInventoryError('search-not-successful');
+            rows = envelope.data;
+        }
+        if (!Array.isArray(rows) || rows.length > this.#options.pageSize)
+            throw new validation.ForgeInventoryError('invalid-page');
+        const items = rows.map(map);
+        let pagination;
+        try {
+            const next = this.next(state, url, headers, rows);
+            pagination = next === null ? { status: 'exhausted' } : state.page >= this.#options.maxPages
+                ? { status: 'incomplete', reason: 'Configured page limit reached.' }
+                : { status: 'more', cursor: this.cursor(next) };
+        }
+        catch {
+            pagination = { status: 'incomplete', reason: 'Invalid or inconsistent pagination metadata.' };
+        }
+        return { schemaVersion: 1, instance: this.instance, scope: { kind: 'instance' }, observation: this.observation(startedAt), items, pagination };
+    }
+    next(state, current, headers, rows) {
+        const keyset = this.#options.kind === 'gitlab' && state.collection === 'repositories';
+        let previousId = BigInt(state.after ?? '0');
+        if (keyset)
+            for (const row of rows) {
+                const id = BigInt(validation.decimal(validation.record(row).id));
+                if (id <= previousId)
+                    throw new Error();
+                previousId = id;
+            }
+        const link = headers.get('link');
+        let nextUrl = null;
+        if (link !== null) {
+            if (link.length > 16_384)
+                throw new Error();
+            for (const entry of link.split(',')) {
+                const match = entry.trim().match(/^<([^<>]+)>;\s*rel="(next|prev|first|last)"$/);
+                if (!match)
+                    throw new Error();
+                if (match[2] !== 'next')
+                    continue;
+                if (nextUrl !== null)
+                    throw new Error();
+                nextUrl = new URL(match[1], current);
+                if (nextUrl.origin !== current.origin || nextUrl.pathname !== current.pathname || nextUrl.username || nextUrl.password || nextUrl.hash)
+                    throw new Error();
+                const expected = new URL(current);
+                const changing = keyset ? 'id_after' : 'page';
+                expected.searchParams.delete(changing);
+                const actual = new URL(nextUrl);
+                if (actual.searchParams.getAll(changing).length !== 1)
+                    throw new Error();
+                actual.searchParams.delete(changing);
+                expected.searchParams.sort();
+                actual.searchParams.sort();
+                if (expected.search !== actual.search)
+                    throw new Error();
+            }
+        }
+        const xNext = headers.get('x-next-page');
+        if (!keyset && xNext !== null && xNext !== '' && validation.decimal(xNext) !== String(state.page + 1))
+            throw new Error();
+        if (rows.length === 0) {
+            if (nextUrl || xNext)
+                throw new Error();
+            return null;
+        }
+        if (keyset) {
+            if (!nextUrl)
+                return null; // GitLab keyset exhaustion is signalled by no next Link.
+            const after = validation.decimal(nextUrl.searchParams.get('id_after'));
+            if (after !== previousId.toString())
+                throw new Error();
+            return { ...state, page: state.page + 1, after };
+        }
+        if (nextUrl && validation.decimal(nextUrl.searchParams.get('page')) !== String(state.page + 1))
+            throw new Error();
+        if (nextUrl && xNext === '')
+            throw new Error();
+        // A short page can reflect a server page-size cap. Probe the following page
+        // even without Link rather than silently truncating at that cap.
+        return { ...state, page: state.page + 1 };
+    }
+    async request(url, requestArg) {
+        const { signal } = requestArg;
+        const maxBytes = requestArg.maxResponseBytes ?? this.#options.maxResponseBytes;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+            throw new validation.ForgeInventoryError('invalid-response-budget');
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        if (signal?.aborted)
+            throw new validation.ForgeInventoryError('request-aborted');
+        signal?.addEventListener('abort', abort, { once: true });
+        const timeout = setTimeout(abort, this.#options.requestTimeoutMs);
+        const deadline = Date.now() + this.#options.requestTimeoutMs;
+        let reader;
+        try {
+            const headers = new Headers({ accept: 'application/json' });
+            if (this.#options.token)
+                headers.set(this.#options.kind === 'gitea' ? 'authorization' : 'private-token', this.#options.kind === 'gitea' ? `token ${this.#options.token}` : this.#options.token);
+            this.#metrics.requests++;
+            const response = await fetch(url, { method: 'GET', headers, redirect: 'error', credentials: 'omit', signal: controller.signal });
+            reader = response.body?.getReader();
+            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' || !reader)
+                throw new validation.ForgeInventoryError('invalid-content-type');
+            const chunks = [];
+            let bytes = 0;
+            while (true) {
+                const result = await reader.read();
+                if (result.done)
+                    break;
+                bytes += result.value.byteLength;
+                this.#metrics.responseBytes += result.value.byteLength;
+                if (bytes > Math.min(maxBytes, this.#options.maxResponseBytes))
+                    throw new validation.ForgeInventoryError('response-size-limit');
+                if (controller.signal.aborted || Date.now() >= deadline)
+                    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 };
+        }
+        catch (error) {
+            if (error instanceof validation.ForgeInventoryError)
+                throw error;
+            throw new validation.ForgeInventoryError(controller.signal.aborted ? 'request-aborted-or-timed-out' : 'request-or-json-failed');
+        }
+        finally {
+            controller.abort();
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', abort);
+            if (reader) {
+                try {
+                    await reader.cancel();
+                }
+                catch { /* The request has already been aborted. */ }
+                reader.releaseLock();
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.forgeinventory.js","sourceRoot":"","sources":["../ts/classes.forgeinventory.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.forgeinventoryscanner.d.ts

@@ -0,0 +1,25 @@
+import type * as plugins from './plugins.js';
+import type { IForgeInventoryMetrics, IForgeInventoryOptions } from './classes.forgeinventory.js';
+export interface IForgeInventoryScanOptions {
+    signal?: AbortSignal;
+    /** Maximum distinct items retained per collection. */
+    maxItems?: number;
+    /** Deadline for the complete scan, including body reads. */
+    timeoutMs?: number;
+    /** Maximum response bytes consumed across both collections. */
+    maxScanResponseBytes?: number;
+}
+export interface IForgeInventoryScan {
+    report: plugins.fossInterfaces.data.IForgeInventoryReport;
+    repositories: plugins.fossInterfaces.data.IForgeInventoryRepository[];
+    namespaces: plugins.fossInterfaces.data.IForgeInventoryNamespace[];
+    metrics: IForgeInventoryMetrics;
+}
+/** A bounded, disposable observation; callers own any durable storage and migration decisions. */
+export declare class ForgeInventoryScanner {
+    #private;
+    constructor(optionsArg: IForgeInventoryOptions);
+    scan(optionsArg?: IForgeInventoryScanOptions): Promise<IForgeInventoryScan>;
+    private capability;
+    private collect;
+}

package/dist_ts/classes.forgeinventoryscanner.js

@@ -0,0 +1,139 @@
+import { ForgeInventoryAdapter, ForgeInventoryError } from './classes.forgeinventory.js';
+import { unknownSize } from './forgeinventory.validation.js';
+const entityClasses = {
+    namespaces: true, users: true, teams: true, memberships: true, repositories: true,
+    gitRefs: true, gitObjects: true, protectedRefs: true, publicSshKeys: true, deployKeys: true,
+    issues: true, issueComments: true, pullRequests: true, reviews: true, reviewComments: true,
+    labels: true, milestones: true, assignees: true, reactions: true, releases: true,
+    releaseAssets: true, lfsObjects: true, packages: true, packageVersions: true, packageBlobs: true,
+    webhooks: true, webhookDeliveries: true, ciWorkflows: true, ciRuns: true, ciArtifacts: true,
+    wikis: true, projects: true,
+};
+/** A bounded, disposable observation; callers own any durable storage and migration decisions. */
+export class ForgeInventoryScanner {
+    #adapter;
+    #running = false;
+    constructor(optionsArg) {
+        this.#adapter = new ForgeInventoryAdapter(optionsArg);
+    }
+    async scan(optionsArg = {}) {
+        const maxItems = optionsArg.maxItems ?? 100_000;
+        const timeoutMs = optionsArg.timeoutMs ?? 60_000;
+        const maxScanResponseBytes = optionsArg.maxScanResponseBytes ?? 64 * 1024 * 1024;
+        if (!Number.isSafeInteger(maxItems) || maxItems < 1 || maxItems > 1_000_000 ||
+            !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 3_600_000 ||
+            !Number.isSafeInteger(maxScanResponseBytes) || maxScanResponseBytes < 1 || maxScanResponseBytes > 1024 * 1024 * 1024) {
+            throw new ForgeInventoryError('invalid-scan-limits');
+        }
+        if (this.#running)
+            throw new ForgeInventoryError('scan-already-running');
+        this.#running = true;
+        const controller = new AbortController();
+        const abort = () => controller.abort();
+        if (optionsArg.signal?.aborted)
+            controller.abort();
+        optionsArg.signal?.addEventListener('abort', abort, { once: true });
+        const timeout = setTimeout(abort, timeoutMs);
+        const before = this.#adapter.metrics;
+        const deadline = Date.now() + timeoutMs;
+        const remainingBytes = () => maxScanResponseBytes - (this.#adapter.metrics.responseBytes - before.responseBytes);
+        const collections = Object.fromEntries(Object.keys(entityClasses).map((key) => [key, {
+                capability: { status: 'unverified', reason: 'No inventory reader has inspected this entity class.' },
+                result: { status: 'notInspected', reason: 'Outside this repository and organization/group scan.' },
+            }]));
+        try {
+            const namespaces = await this.collect((request) => this.#adapter.listNamespaces(request), maxItems, controller.signal, deadline, remainingBytes);
+            const repositories = await this.collect((request) => this.#adapter.listRepositories(request), maxItems, controller.signal, deadline, remainingBytes);
+            const namespaceLimitation = 'Only organization/group namespaces were inspected; personal namespaces and full private namespace coverage remain uninspected.';
+            collections.namespaces = {
+                capability: this.capability(namespaces, [namespaceLimitation, 'Live API visibility does not prove administrator completeness.']),
+                result: namespaces.result.status === 'enumerated' ? {
+                    status: 'incomplete', observation: namespaces.result.observation,
+                    observedCount: namespaces.result.count, reason: namespaceLimitation,
+                } : namespaces.result,
+            };
+            const repositoryResult = repositories.result;
+            if (repositoryResult.status === 'enumerated') {
+                const measurements = repositories.items.map((item) => item.gitSizeBytes);
+                repositoryResult.sizeBytes = measurements.length > 0 && measurements.every((size) => size.status === 'measured')
+                    ? { status: 'measured', value: measurements.reduce((sum, size) => sum + (size.status === 'measured' ? BigInt(size.value) : 0n), 0n).toString(), accuracy: 'estimate' }
+                    : unknownSize('Separate Git byte measurements were not available for every repository.');
+            }
+            collections.repositories = {
+                capability: this.capability(repositories, ['Only API-visible repositories are enumerated.', 'Live pagination is not a frozen export.', 'Git size statistics do not measure outgoing push bytes.']),
+                result: repositoryResult,
+            };
+            const after = this.#adapter.metrics;
+            return {
+                report: {
+                    schemaVersion: 1, instance: this.#adapter.instance, scope: { kind: 'instance' }, collections,
+                    additionalCollections: [{
+                            name: this.#adapter.instance.kind === 'gitea' ? 'gitea.organizations' : 'gitlab.groups',
+                            capability: this.capability(namespaces, ['Endpoint visibility and live pagination limits apply.']),
+                            result: namespaces.result,
+                        }],
+                },
+                repositories: repositories.items, namespaces: namespaces.items,
+                metrics: {
+                    requests: after.requests - before.requests,
+                    responseBytes: after.responseBytes - before.responseBytes,
+                    rateLimitedRequests: after.rateLimitedRequests - before.rateLimitedRequests,
+                },
+            };
+        }
+        finally {
+            controller.abort();
+            clearTimeout(timeout);
+            optionsArg.signal?.removeEventListener('abort', abort);
+            this.#running = false;
+        }
+    }
+    capability(collection, limitations) {
+        return collection.result.status === 'enumerated' || collection.items.length > 0
+            ? { status: 'available', limitations }
+            : { status: 'unverified', reason: 'No successful enumeration or entity observation established this reader capability.' };
+    }
+    async collect(read, maxItems, signal, deadline, remainingBytes) {
+        const startedAt = new Date().toISOString();
+        const items = [];
+        const identities = new Set();
+        let cursor;
+        const incomplete = (reason) => ({ items, result: {
+                status: 'incomplete', observation: this.#adapter.observation(startedAt), observedCount: String(items.length), reason,
+            } });
+        while (true) {
+            if (signal.aborted || Date.now() >= deadline)
+                return incomplete('Scan aborted or deadline reached.');
+            if (remainingBytes() <= 0)
+                return incomplete('Configured scan response-byte limit reached.');
+            let page;
+            try {
+                page = await read({ cursor, signal, maxResponseBytes: remainingBytes() });
+            }
+            catch (error) {
+                return incomplete(error instanceof ForgeInventoryError ? error.message : 'Inventory request failed.');
+            }
+            for (const item of page.items) {
+                if (item.identity.status !== 'identified')
+                    return incomplete('Stable provider identity was not available.');
+                const key = JSON.stringify(item.identity.ref);
+                if (identities.has(key))
+                    return incomplete('Repeated provider identity during live pagination.');
+                if (items.length >= maxItems)
+                    return incomplete('Configured item limit reached.');
+                identities.add(key);
+                items.push(item);
+            }
+            if (signal.aborted || Date.now() >= deadline)
+                return incomplete('Scan aborted or deadline reached.');
+            if (page.pagination.status === 'incomplete')
+                return incomplete(page.pagination.reason);
+            if (page.pagination.status === 'exhausted')
+                return {
+                    items, result: { status: 'enumerated', observation: this.#adapter.observation(startedAt), count: String(items.length), sizeBytes: unknownSize('No byte measurement for this collection.') },
+                };
+            cursor = page.pagination.cursor;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.forgeinventoryscanner.js","sourceRoot":"","sources":["../ts/classes.forgeinventoryscanner.ts"],"names":[],"mappings":"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"}