@foss.global/gitmanager 1.4.0 → 1.6.0

package/changelog.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 2026-08-04 - 1.6.0
+
+### Features
+
+- add bounded GitManager readiness checks (readiness)
+  - Add checkReadiness() with timeout validation and AbortSignal cancellation support.
+  - Return structured readiness failure reasons for lifecycle, abort, timeout, and unavailable states.
+  - Use Smart HTTP /healthz loopback probes when available to keep readiness responsive while management commands are busy.
+
+## 2026-07-31 - 1.5.0
+
+### Features
+
+- validate repository archive extraction metadata (repository-archives)
+  - Inspect generated tar.gz archives before publication and reject invalid structure, unsafe paths, symlink cycles, trailing data, or exceeded limits.
+  - Add maxArchiveExtractedBytes and maxArchiveEntries options with defaults and runtime validation.
+  - Return extractedSizeBytes and entryCount from createRepositoryArchive and validate those values in the TypeScript bridge.
+  - Hold exclusive transfer directory ownership while running and clean interrupted archive temporary files on startup.
+  - Add archive conformance and limit coverage for metadata validation.
+
 ## 2026-07-21 - 1.4.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@foss.global/gitmanager',
-    version: '1.4.0',
+    version: '1.6.0',
     description: 'Headless Git manager for the foss.global Git platform, with a TypeScript API and Rust engine.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLCtGQUErRjtDQUM3RyxDQUFBIn0=

package/dist_ts/classes.gitmanager.d.ts

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import type { IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffRequest, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRef, IGitManagerRefRequest, IGitManagerProtectedRefsApplyResult, IGitManagerSmartHttpRepositoryProtectedRefs, IGitManagerRepositoryBundle, IGitManagerRepositoryArchive, IGitManagerRepositoryArchiveRequest, IGitManagerRepositoryLfsPointer, IGitManagerRepositoryServiceRequest, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerRestoreBundleRequest, IGitManagerSmartHttpRepositoryAccess, IGitManagerSmartHttpRepositoryVisibility, IGitManagerStatus, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, IGitManagerOptions } from './models.js';
+import type { IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffRequest, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRef, IGitManagerRefRequest, IGitManagerProtectedRefsApplyResult, IGitManagerSmartHttpRepositoryProtectedRefs, IGitManagerRepositoryBundle, IGitManagerRepositoryArchive, IGitManagerRepositoryArchiveRequest, IGitManagerRepositoryLfsPointer, IGitManagerRepositoryServiceRequest, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerRestoreBundleRequest, IGitManagerSmartHttpRepositoryAccess, IGitManagerSmartHttpRepositoryVisibility, IGitManagerStatus, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, IGitManagerOptions, IGitManagerReadinessOptions, TGitManagerReadinessResult } from './models.js';
 import { GitManagerRepositoryService } from './classes.repositoryservice.js';
 export declare class GitManager extends plugins.EventEmitter {
     private bridge;
@@ -8,10 +8,22 @@ export declare class GitManager extends plugins.EventEmitter {
     private stopRequested;
     private config;
     private readonly repositoryServices;
+    private lifecycleEpoch;
+    private smartHttpProbeUrl;
+    private readonly activeReadinessControllers;
+    private managementStatusProbePromise;
     constructor(optionsArg?: IGitManagerOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
     getStatus(): Promise<IGitManagerStatus>;
+    /**
+     * Performs a bounded, read-only probe to verify engine readiness. When Git
+     * Smart HTTP is configured, the probe uses its independent /healthz route so
+     * readiness stays available while the serial management loop is busy with a
+     * long-running command; otherwise a single-flight bounded getStatus round
+     * trip is used, which queues behind in-flight management commands.
+     */
+    checkReadiness(optionsArg?: IGitManagerReadinessOptions): Promise<TGitManagerReadinessResult>;
     setSmartHttpRepositoryAccess(accessArg: IGitManagerSmartHttpRepositoryAccess): Promise<void>;
     setSmartHttpRepositoryVisibility(visibilityArg: IGitManagerSmartHttpRepositoryVisibility): Promise<void>;
     setSmartHttpRepositoryProtectedRefs(protectedRefsArg: IGitManagerSmartHttpRepositoryProtectedRefs): Promise<IGitManagerProtectedRefsApplyResult>;
@@ -36,6 +48,13 @@ export declare class GitManager extends plugins.EventEmitter {
     listTags(requestArg: IGitManagerListTagsRequest): Promise<IGitManagerTag[]>;
     getTag(requestArg: IGitManagerTagRequest): Promise<IGitManagerTag>;
     private startInternal;
+    private captureSmartHttpProbeUrl;
+    private resolveSmartHttpProbeUrl;
+    private probeSmartHttpHealth;
+    private probeManagementStatus;
+    private getReadinessLifecycleReason;
+    private createReadinessFailure;
+    private abortActiveReadinessProbes;
     private assertRunning;
     private closeRepositoryServices;
 }

package/dist_ts/classes.gitmanager.js

@@ -1,6 +1,8 @@
 import * as plugins from './plugins.js';
 import { RustGitManagerBridge } from './rust-gitmanager-bridge.js';
 import { GitManagerRepositoryService } from './classes.repositoryservice.js';
+const readinessDefaultTimeoutMs = 2_000;
+const readinessMaximumTimeoutMs = 30_000;
 export class GitManager extends plugins.EventEmitter {
     constructor(optionsArg = {}) {
         super();
@@ -9,6 +11,10 @@ export class GitManager extends plugins.EventEmitter {
         this.startPromise = null;
         this.stopRequested = false;
         this.repositoryServices = new Set();
+        this.lifecycleEpoch = 0;
+        this.smartHttpProbeUrl = null;
+        this.activeReadinessControllers = new Set();
+        this.managementStatusProbePromise = null;
         const dataDir = optionsArg.dataDir
             ?? plugins.path.resolve(process.cwd(), '.nogit', 'gitmanager');
         const smartHttpOptions = optionsArg.smartHttp;
@@ -17,6 +23,8 @@ export class GitManager extends plugins.EventEmitter {
             transferDir: optionsArg.transferDir ?? plugins.path.join(dataDir, 'transfers'),
             maxBundleBytes: optionsArg.maxBundleBytes ?? 8 * 1024 * 1024 * 1024,
             maxArchiveBytes: optionsArg.maxArchiveBytes ?? 128 * 1024 * 1024,
+            maxArchiveExtractedBytes: optionsArg.maxArchiveExtractedBytes ?? 64 * 1024 * 1024 * 1024,
+            maxArchiveEntries: optionsArg.maxArchiveEntries ?? 1_000_000,
             smartHttp: smartHttpOptions && smartHttpOptions.enabled !== false
                 ? {
                     bindAddress: smartHttpOptions.bindAddress ?? '127.0.0.1',
@@ -53,6 +61,9 @@ export class GitManager extends plugins.EventEmitter {
         };
         this.bridge.on('exit', (code, signal) => {
             this.started = false;
+            this.lifecycleEpoch++;
+            this.smartHttpProbeUrl = null;
+            this.abortActiveReadinessProbes();
             this.emit('exit', code, signal);
         });
         this.bridge.on('stderr', (line) => {
@@ -67,6 +78,7 @@ export class GitManager extends plugins.EventEmitter {
             throw new Error('GitManager is already starting');
         }
         this.stopRequested = false;
+        this.lifecycleEpoch++;
         this.startPromise = this.startInternal();
         try {
             await this.startPromise;
@@ -77,6 +89,9 @@ export class GitManager extends plugins.EventEmitter {
     }
     async stop() {
         this.stopRequested = true;
+        this.lifecycleEpoch++;
+        this.smartHttpProbeUrl = null;
+        this.abortActiveReadinessProbes();
         if (this.startPromise) {
             await this.startPromise.catch(() => undefined);
         }
@@ -104,6 +119,78 @@ export class GitManager extends plugins.EventEmitter {
         }
         return this.bridge.getStatus();
     }
+    /**
+     * Performs a bounded, read-only probe to verify engine readiness. When Git
+     * Smart HTTP is configured, the probe uses its independent /healthz route so
+     * readiness stays available while the serial management loop is busy with a
+     * long-running command; otherwise a single-flight bounded getStatus round
+     * trip is used, which queues behind in-flight management commands.
+     */
+    async checkReadiness(optionsArg = {}) {
+        const startedAt = performance.now();
+        const timeoutMs = optionsArg.timeoutMs ?? readinessDefaultTimeoutMs;
+        if (!Number.isSafeInteger(timeoutMs) ||
+            timeoutMs <= 0 ||
+            timeoutMs > readinessMaximumTimeoutMs) {
+            throw new TypeError(`Readiness timeoutMs must be a positive safe integer no greater than ${readinessMaximumTimeoutMs}.`);
+        }
+        const callerSignal = optionsArg.signal;
+        if (callerSignal?.aborted) {
+            return this.createReadinessFailure('aborted', startedAt);
+        }
+        const lifecycleReason = this.getReadinessLifecycleReason();
+        if (lifecycleReason) {
+            return this.createReadinessFailure(lifecycleReason, startedAt);
+        }
+        const lifecycleEpoch = this.lifecycleEpoch;
+        const readinessController = new AbortController();
+        let abortSource;
+        const abortForCaller = () => {
+            if (!abortSource) {
+                abortSource = 'caller';
+            }
+            readinessController.abort();
+        };
+        callerSignal?.addEventListener('abort', abortForCaller, { once: true });
+        const deadlineTimer = setTimeout(() => {
+            if (!abortSource) {
+                abortSource = 'deadline';
+            }
+            readinessController.abort();
+        }, timeoutMs);
+        this.activeReadinessControllers.add(readinessController);
+        let probeOutcome;
+        try {
+            probeOutcome = this.smartHttpProbeUrl
+                ? await this.probeSmartHttpHealth(this.smartHttpProbeUrl, readinessController.signal)
+                : await this.probeManagementStatus(readinessController.signal);
+        }
+        finally {
+            clearTimeout(deadlineTimer);
+            callerSignal?.removeEventListener('abort', abortForCaller);
+            this.activeReadinessControllers.delete(readinessController);
+        }
+        if (this.lifecycleEpoch !== lifecycleEpoch) {
+            return this.createReadinessFailure(this.getReadinessLifecycleReason() ?? 'unavailable', startedAt);
+        }
+        if (probeOutcome === 'aborted') {
+            if (abortSource === 'caller') {
+                return this.createReadinessFailure('aborted', startedAt);
+            }
+            if (abortSource === 'deadline') {
+                return this.createReadinessFailure('timeout', startedAt);
+            }
+            return this.createReadinessFailure('unavailable', startedAt);
+        }
+        if (probeOutcome === 'unavailable') {
+            return this.createReadinessFailure('unavailable', startedAt);
+        }
+        return {
+            ready: true,
+            status: 'ready',
+            durationMs: performance.now() - startedAt,
+        };
+    }
     async setSmartHttpRepositoryAccess(accessArg) {
         this.assertRunning();
         return this.bridge.setSmartHttpRepositoryAccess({
@@ -249,6 +336,7 @@ export class GitManager extends plugins.EventEmitter {
                 throw new Error('GitManager start was cancelled');
             }
             this.started = true;
+            await this.captureSmartHttpProbeUrl();
         }
         catch (error) {
             this.bridge.kill();
@@ -256,6 +344,150 @@ export class GitManager extends plugins.EventEmitter {
             throw error;
         }
     }
+    async captureSmartHttpProbeUrl() {
+        if (!this.config.smartHttp) {
+            return;
+        }
+        try {
+            const status = await this.bridge.getStatus({ timeoutMs: 5_000 });
+            this.smartHttpProbeUrl = this.resolveSmartHttpProbeUrl(status);
+        }
+        catch {
+            this.smartHttpProbeUrl = null;
+        }
+    }
+    resolveSmartHttpProbeUrl(statusArg) {
+        const smartHttpStatus = statusArg.smartHttp;
+        if (!smartHttpStatus?.running || !smartHttpStatus.baseUrl) {
+            return null;
+        }
+        let baseUrl;
+        try {
+            baseUrl = new URL(smartHttpStatus.baseUrl);
+        }
+        catch {
+            return null;
+        }
+        if (baseUrl.hostname === '0.0.0.0') {
+            baseUrl.hostname = '127.0.0.1';
+        }
+        else if (baseUrl.hostname === '::' || baseUrl.hostname === '[::]') {
+            baseUrl.hostname = '[::1]';
+        }
+        const hostname = baseUrl.hostname;
+        const isLoopback = hostname === 'localhost' ||
+            hostname === '::1' ||
+            hostname === '[::1]' ||
+            hostname.startsWith('127.');
+        if (!isLoopback) {
+            return null;
+        }
+        return baseUrl.origin;
+    }
+    probeSmartHttpHealth(probeUrlArg, signalArg) {
+        return new Promise((resolve) => {
+            let settled = false;
+            let healthRequest;
+            const settle = (outcomeArg) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                signalArg.removeEventListener('abort', abortProbe);
+                resolve(outcomeArg);
+            };
+            const abortProbe = () => {
+                healthRequest?.destroy();
+                settle('aborted');
+            };
+            signalArg.addEventListener('abort', abortProbe, { once: true });
+            if (signalArg.aborted) {
+                abortProbe();
+                return;
+            }
+            try {
+                healthRequest = plugins.http.request(new URL('/healthz', probeUrlArg), { method: 'GET', agent: false }, (response) => {
+                    const outcome = response.statusCode === 200 ? 'ready' : 'unavailable';
+                    // The body is never needed; destroying immediately keeps a peer
+                    // that stalls mid-body from retaining the socket indefinitely.
+                    healthRequest?.destroy();
+                    settle(outcome);
+                });
+                healthRequest.on('error', () => settle('unavailable'));
+                healthRequest.end();
+            }
+            catch {
+                settle('unavailable');
+            }
+        });
+    }
+    probeManagementStatus(signalArg) {
+        if (!this.managementStatusProbePromise) {
+            const probeEpoch = this.lifecycleEpoch;
+            const managementProbe = this.bridge
+                .getStatus({ timeoutMs: readinessMaximumTimeoutMs })
+                .then((status) => {
+                if (this.lifecycleEpoch === probeEpoch &&
+                    this.config.smartHttp &&
+                    !this.smartHttpProbeUrl) {
+                    this.smartHttpProbeUrl = this.resolveSmartHttpProbeUrl(status);
+                }
+                return status.running ? 'ready' : 'unavailable';
+            }, () => 'unavailable');
+            this.managementStatusProbePromise = managementProbe;
+            void managementProbe.finally(() => {
+                if (this.managementStatusProbePromise === managementProbe) {
+                    this.managementStatusProbePromise = null;
+                }
+            });
+        }
+        const sharedProbe = this.managementStatusProbePromise;
+        return new Promise((resolve) => {
+            let settled = false;
+            const settle = (outcomeArg) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                signalArg.removeEventListener('abort', abortWait);
+                resolve(outcomeArg);
+            };
+            const abortWait = () => {
+                settle('aborted');
+            };
+            signalArg.addEventListener('abort', abortWait, { once: true });
+            if (signalArg.aborted) {
+                abortWait();
+                return;
+            }
+            void sharedProbe.then(settle);
+        });
+    }
+    getReadinessLifecycleReason() {
+        if (this.startPromise) {
+            return 'starting';
+        }
+        if (!this.running) {
+            return 'not_running';
+        }
+        if (this.stopRequested) {
+            return 'stopping';
+        }
+        return undefined;
+    }
+    createReadinessFailure(reasonArg, startedAtArg) {
+        return {
+            ready: false,
+            status: 'unavailable',
+            reason: reasonArg,
+            durationMs: performance.now() - startedAtArg,
+        };
+    }
+    abortActiveReadinessProbes() {
+        for (const readinessController of [...this.activeReadinessControllers]) {
+            readinessController.abort();
+        }
+    }
     assertRunning() {
         if (!this.running) {
             throw new Error('GitManager is not running');
@@ -267,4 +499,4 @@ export class GitManager extends plugins.EventEmitter {
         await Promise.all(services.map((service) => service.close()));
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.gitmanager.js","sourceRoot":"","sources":["../ts/classes.gitmanager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.gitmanager.js","sourceRoot":"","sources":["../ts/classes.gitmanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/models.d.ts

@@ -61,6 +61,8 @@ export interface IGitManagerRepositoryArchive extends IGitManagerRepositorySelec
     archivePath: string;
     sizeBytes: number;
     sha256: string;
+    extractedSizeBytes: number;
+    entryCount: number;
 }
 export interface IGitManagerRepositoryLfsPointer {
     oid: string;
@@ -93,6 +95,8 @@ export interface IGitManagerOptions {
     transferDir?: string;
     maxBundleBytes?: number;
     maxArchiveBytes?: number;
+    maxArchiveExtractedBytes?: number;
+    maxArchiveEntries?: number;
     smartHttp?: IGitManagerSmartHttpOptions;
 }
 export interface IRustGitManagerSmartHttpConfig {
@@ -123,6 +127,8 @@ export interface IRustGitManagerConfig {
     transferDir: string;
     maxBundleBytes: number;
     maxArchiveBytes: number;
+    maxArchiveExtractedBytes: number;
+    maxArchiveEntries: number;
     smartHttp?: IRustGitManagerSmartHttpConfig;
 }
 export interface IGitManagerSmartHttpStatus {
@@ -137,4 +143,19 @@ export interface IGitManagerStatus {
     uptimeMs: number;
     smartHttp?: IGitManagerSmartHttpStatus;
 }
+export interface IGitManagerReadinessOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export type TGitManagerReadinessFailureReason = 'not_running' | 'starting' | 'stopping' | 'aborted' | 'timeout' | 'unavailable';
+export type TGitManagerReadinessResult = {
+    ready: true;
+    status: 'ready';
+    durationMs: number;
+} | {
+    ready: false;
+    status: 'unavailable';
+    reason: TGitManagerReadinessFailureReason;
+    durationMs: number;
+};
 export type { IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffFile, IGitManagerDiffHunk, IGitManagerDiffLine, IGitManagerDiffRequest, IGitManagerDiffStats, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRef, IGitManagerRefRequest, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, TGitManagerDiffFileStatus, TGitManagerDiffLineKind, TGitManagerMergeMethod, TGitManagerMergeStatus, TGitManagerObjectType, TGitManagerRefType, TGitManagerTreeEntryType, } from '@foss.global/interfaces';

package/dist_ts/plugins.d.ts

@@ -1,8 +1,9 @@
 import * as childProcess from 'node:child_process';
 import { EventEmitter } from 'node:events';
+import * as http from 'node:http';
 import * as path from 'node:path';
 import * as stream from 'node:stream';
 import * as url from 'node:url';
-export { childProcess, EventEmitter, path, stream, url };
+export { childProcess, EventEmitter, http, path, stream, url };
 import * as smartrust from '@push.rocks/smartrust';
 export { smartrust };

package/dist_ts/plugins.js

@@ -1,11 +1,12 @@
 // node native scope
 import * as childProcess from 'node:child_process';
 import { EventEmitter } from 'node:events';
+import * as http from 'node:http';
 import * as path from 'node:path';
 import * as stream from 'node:stream';
 import * as url from 'node:url';
-export { childProcess, EventEmitter, path, stream, url };
+export { childProcess, EventEmitter, http, path, stream, url };
 // @push.rocks scope
 import * as smartrust from '@push.rocks/smartrust';
 export { smartrust };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMzQyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssR0FBRyxNQUFNLFVBQVUsQ0FBQztBQUVoQyxPQUFPLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUFDO0FBRXpELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxTQUFTLEVBQUUsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMzQyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssR0FBRyxNQUFNLFVBQVUsQ0FBQztBQUVoQyxPQUFPLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQztBQUUvRCxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUVuRCxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==

package/dist_ts/rust-gitmanager-bridge.d.ts

@@ -8,7 +8,7 @@ export declare class RustGitManagerBridge extends plugins.EventEmitter {
     get running(): boolean;
     startGitManager(configArg: IRustGitManagerConfig): Promise<void>;
     stopGitManager(): Promise<void>;
-    getStatus(): Promise<IGitManagerStatus>;
+    getStatus(optionsArg?: plugins.smartrust.IRustBridgeRequestOptions): Promise<IGitManagerStatus>;
     setSmartHttpRepositoryAccess(accessArg: IGitManagerSmartHttpRepositoryAccess): Promise<void>;
     setSmartHttpRepositoryVisibility(visibilityArg: IGitManagerSmartHttpRepositoryVisibility): Promise<void>;
     setSmartHttpRepositoryProtectedRefs(protectedRefsArg: IGitManagerSmartHttpRepositoryProtectedRefs): Promise<IGitManagerProtectedRefsApplyResult>;

package/dist_ts/rust-gitmanager-bridge.js

@@ -55,8 +55,8 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     async stopGitManager() {
         await this.bridge.sendCommand('stop', {});
     }
-    async getStatus() {
-        return this.bridge.sendCommand('getStatus', {});
+    async getStatus(optionsArg) {
+        return this.bridge.sendCommand('getStatus', {}, optionsArg);
     }
     async setSmartHttpRepositoryAccess(accessArg) {
         await this.bridge.sendCommand('setSmartHttpRepositoryAccess', accessArg);
@@ -83,7 +83,19 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
         return this.bridge.sendCommand('createRepositoryBundle', requestArg);
     }
     async createRepositoryArchive(requestArg) {
-        return this.bridge.sendCommand('createRepositoryArchive', requestArg);
+        const result = await this.bridge.sendCommand('createRepositoryArchive', requestArg, {
+            timeoutMs: 65 * 60 * 1000,
+        });
+        for (const [field, value] of [
+            ['sizeBytes', result.sizeBytes],
+            ['extractedSizeBytes', result.extractedSizeBytes],
+            ['entryCount', result.entryCount],
+        ]) {
+            if (!Number.isSafeInteger(value) || value < 0) {
+                throw new Error(`Rust GitManager returned an invalid ${field}`);
+            }
+        }
+        return result;
     }
     async prepareRepositoryService(requestArg) {
         return this.bridge.sendCommand('prepareRepositoryService', requestArg);
@@ -125,4 +137,4 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
         return this.bridge.sendCommand('getTag', requestArg);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVzdC1naXRtYW5hZ2VyLWJyaWRnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3J1c3QtZ2l0bWFuYWdlci1icmlkZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFrRXhDLFNBQVMsY0FBYztJQUNyQixNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDakYsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDN0MsQ0FBQztBQUVELFNBQVMsdUJBQXVCO0lBQzlCLE1BQU0sT0FBTyxHQUEyQixFQUFFLEdBQUcsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQ3pFLE1BQU0sS0FBSyxHQUEyQixFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQzFFLE1BQU0sRUFBRSxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDbkMsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNuQyxPQUFPLEVBQUUsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7QUFDN0MsQ0FBQztBQUVELFNBQVMsZUFBZTtJQUN0QixNQUFNLFdBQVcsR0FBRyxjQUFjLEVBQUUsQ0FBQztJQUNyQyxNQUFNLE1BQU0sR0FBRyx1QkFBdUIsRUFBRSxDQUFDO0lBQ3pDLE1BQU0sS0FBSyxHQUFhLEVBQUUsQ0FBQztJQUUzQixJQUFJLE1BQU0sRUFBRSxDQUFDO1FBQ1gsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsV0FBVyxFQUFFLGtCQUFrQixNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDdEYsQ0FBQztJQUNELEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7SUFDMUUsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDO0lBQy9GLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLGdCQUFnQixDQUFDLENBQUMsQ0FBQztJQUU3RixPQUFPLEtBQUssQ0FBQztBQUNmLENBQUM7QUFFRCxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsT0FBTyxDQUFDLFlBQVk7SUFHNUQ7UUFDRSxLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBc0I7WUFDbEUsVUFBVSxFQUFFLGdCQUFnQjtZQUM1QixVQUFVLEVBQUUsd0JBQXdCO1lBQ3BDLHFCQUFxQixFQUFFLHlCQUF5QjtZQUNoRCxVQUFVLEVBQUUsZUFBZSxFQUFFO1lBQzdCLGdCQUFnQixFQUFFLE1BQU07WUFDeEIsY0FBYyxFQUFFLEtBQUs7U0FDdEIsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsSUFBbUIsRUFBRSxNQUFxQixFQUFFLEVBQUU7WUFDcEUsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ2xDLENBQUMsQ0FBQyxDQUFDO1FBQ0gsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLENBQUMsSUFBWSxFQUFFLEVBQUU7WUFDeEMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDNUIsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUs7UUFDaEIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFFTSxJQUFJO1FBQ1QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNyQixDQUFDO0lBRUQsSUFBVyxPQUFPO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUM7SUFDN0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxlQUFlLENBQUMsU0FBZ0M7UUFDM0QsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQUUsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRU0sS0FBSyxDQUFDLGNBQWM7UUFDekIsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVNLEtBQUssQ0FBQyxTQUFTLENBQ3BCLFVBQXdEO1FBRXhELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsV0FBVyxFQUFFLEVBQUUsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRU0sS0FBSyxDQUFDLDRCQUE0QixDQUFDLFNBQStDO1FBQ3ZGLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsOEJBQThCLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDM0UsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQ0FBZ0MsQ0FDM0MsYUFBdUQ7UUFFdkQsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxrQ0FBa0MsRUFBRSxhQUFhLENBQUMsQ0FBQztJQUNuRixDQUFDO0lBRU0sS0FBSyxDQUFDLG1DQUFtQyxDQUM5QyxnQkFBNkQ7UUFFN0QsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FDNUIscUNBQXFDLEVBQ3JDLGdCQUFnQixDQUNqQixDQUFDO0lBQ0osQ0FBQztJQUVNLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxVQUFnRDtRQUM5RSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLG9CQUFvQixFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ25FLENBQUM7SUFFTSxLQUFLLENBQUMsWUFBWSxDQUFDLFVBQTBDO1FBQ2xFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsY0FBYyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFTSxLQUFLLENBQUMsYUFBYSxDQUFDLFVBQXlDO1FBQ2xFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsZUFBZSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFFTSxLQUFLLENBQUMsZ0JBQWdCLENBQUMsVUFBeUM7UUFDckUsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxrQkFBa0IsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUNqRSxDQUFDO0lBRU0sS0FBSyxDQUFDLHNCQUFzQixDQUNqQyxVQUF5QztRQUV6QyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLHdCQUF3QixFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3ZFLENBQUM7SUFFTSxLQUFLLENBQUMsdUJBQXVCLENBQ2xDLFVBQStDO1FBRS9DLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMseUJBQXlCLEVBQUUsVUFBVSxFQUFFO1lBQ2xGLFNBQVMsRUFBRSxFQUFFLEdBQUcsRUFBRSxHQUFHLElBQUk7U0FDMUIsQ0FBQyxDQUFDO1FBQ0gsS0FBSyxNQUFNLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxJQUFJO1lBQzNCLENBQUMsV0FBVyxFQUFFLE1BQU0sQ0FBQyxTQUFTLENBQUM7WUFDL0IsQ0FBQyxvQkFBb0IsRUFBRSxNQUFNLENBQUMsa0JBQWtCLENBQUM7WUFDakQsQ0FBQyxZQUFZLEVBQUUsTUFBTSxDQUFDLFVBQVUsQ0FBQztTQUN6QixFQUFFLENBQUM7WUFDWCxJQUFJLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQzlDLE1BQU0sSUFBSSxLQUFLLENBQUMsdUNBQXVDLEtBQUssRUFBRSxDQUFDLENBQUM7WUFDbEUsQ0FBQztRQUNILENBQUM7UUFDRCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRU0sS0FBSyxDQUFDLHdCQUF3QixDQUNuQyxVQUErQztRQUUvQyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLDBCQUEwQixFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7SUFFTSxLQUFLLENBQUMsdUJBQXVCLENBQ2xDLFVBQTJDO1FBRTNDLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMseUJBQXlCLEVBQUUsVUFBVSxDQUFDLENBQUM7SUFDeEUsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0I7UUFDM0IsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUN6RCxDQUFDO0lBRU0sS0FBSyxDQUFDLFFBQVEsQ0FBQyxVQUFpQztRQUNyRCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUN6RCxDQUFDO0lBRU0sS0FBSyxDQUFDLHlCQUF5QixDQUNwQyxVQUF5QztRQUV6QyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLDJCQUEyQixFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzFFLENBQUM7SUFFTSxLQUFLLENBQUMsZUFBZSxDQUMxQixVQUFtQztRQUVuQyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGlCQUFpQixFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7SUFFTSxLQUFLLENBQUMsUUFBUSxDQUFDLFVBQWtDO1FBQ3RELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFTSxLQUFLLENBQUMsUUFBUSxDQUFDLFVBQXNDO1FBQzFELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFTSxLQUFLLENBQUMsV0FBVyxDQUFDLFVBQXlDO1FBQ2hFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsYUFBYSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzVELENBQUM7SUFFTSxLQUFLLENBQUMsU0FBUyxDQUFDLFVBQW9DO1FBQ3pELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsV0FBVyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTyxDQUFDLFVBQWtDO1FBQ3JELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsU0FBUyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFTSxLQUFLLENBQUMsUUFBUSxDQUFDLFVBQXNDO1FBQzFELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFTSxLQUFLLENBQUMsTUFBTSxDQUFDLFVBQWlDO1FBQ25ELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsUUFBUSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7Q0FDRiJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foss.global/gitmanager",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "private": false,
   "description": "Headless Git manager for the foss.global Git platform, with a TypeScript API and Rust engine.",
   "exports": {
@@ -10,15 +10,16 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "dependencies": {
-    "@foss.global/interfaces": "^0.10.0",
-    "@push.rocks/smartrust": "^1.4.0"
+    "@foss.global/interfaces": "^0.11.0",
+    "@push.rocks/smartrust": "^1.5.0"
   },
   "devDependencies": {
+    "@foss.global/ci-spec": "0.2.0",
     "@git.zone/tsbuild": "^4.4.2",
     "@git.zone/tsdoc": "^2.1.1",
-    "@git.zone/tsrun": "^2.0.5",
-    "@git.zone/tsrust": "^1.6.0",
-    "@git.zone/tstest": "^3.6.6",
+    "@git.zone/tsrun": "^2.0.6",
+    "@git.zone/tsrust": "^1.7.0",
+    "@git.zone/tstest": "^3.6.7",
     "@types/node": "^26.1.1"
   },
   "files": [

package/readme.md

@@ -74,7 +74,9 @@ await gitManager.restoreRepositoryBundle({
 
 `transferDir` defaults to `<dataDir>/transfers`; both paths must be absolute. `maxBundleBytes` defaults to 8 GiB and is enforced after export and before restore. Restore accepts only a direct, non-empty `.bundle` file inside `transferDir`, requires the declared default branch, runs strict full `git fsck`, and moves the restored bare repository into place atomically. Empty repositories have no Git refs and therefore cannot produce a bundle; persist their catalog metadata and recreate them with `initBareRepository()`.
 
-The transfer directory is disposable staging, not persistence. The caller owns upload/download completion and removal of finished transfer files. Durable repository bytes belong in managed object storage.
+Exact-commit source archives default to a 128 MiB compressed limit, a 64 GiB extracted regular-file limit, and 1,000,000 filesystem entries. Configure these with `maxArchiveBytes`, `maxArchiveExtractedBytes`, and `maxArchiveEntries`; their hard ceilings are 16 GiB, 64 GiB, and 1,000,000 respectively. CI source consumers apply their negotiated compressed limit, which is at most 8 GiB in runner protocol v2. Before publication, GitManager validates the exact generated gzip/tar stream against the returned `extractedSizeBytes` and `entryCount`, including paths, entry types, links, PAX metadata, checksums, padding, and archive terminators.
+
+The transfer directory is disposable staging, not persistence. GitManager holds exclusive ownership of it while running so startup can safely remove interrupted archive temporary files. The caller owns upload/download completion and removal of finished transfer files. Durable repository bytes belong in managed object storage.
 
 ## Git Smart HTTP
 
@@ -209,12 +211,26 @@ const result = await service.completed;
 
 The returned service counts request, response, and stderr bytes, runs with an isolated Git environment, has its own process group and deadline, and is terminated when `GitManager.stop()` runs. Receive-pack uses the same private managed pre-receive hook and exact policy snapshot as Smart HTTP. The caller must authenticate the SSH key, authorize the repository operation, cap sessions, serialize writes with HTTP pushes and policy changes, inspect refs, persist the repository, record downstream events, and withhold the final receive-pack status until all durable work succeeds.
 
+## Bounded readiness
+
+`checkReadiness()` performs one bounded, read-only probe. Lifecycle states return failure results instead of throwing; only an invalid `timeoutMs` throws a `TypeError`. The default timeout is 2000 ms, the maximum is 30000 ms, and an `AbortSignal` cancels the local wait.
+
+```ts
+const readiness = await gitManager.checkReadiness({ timeoutMs: 2000 });
+if (!readiness.ready) {
+  console.error(`GitManager unavailable: ${readiness.reason}`);
+}
+```
+
+When Git Smart HTTP is running on a loopback bind, the probe targets the engine's own `GET /healthz` route out-of-band, so readiness stays available while the serial management channel is busy with a long-running command such as a mirror import or archive creation. Without a loopback Smart HTTP route, including a service bound to a non-loopback address with `allowUnsafeNonLoopback`, one shared bounded `getStatus` round trip per instance is used; that fallback queues behind in-flight management commands and a Smart HTTP probe failure never falls through to it. Failure reasons are `not_running`, `starting`, `stopping`, `aborted`, `timeout`, and `unavailable`; the result matches the readiness contracts of `@push.rocks/smartdata` and `@push.rocks/smartbucket`.
+
 ## Public API
 
 - `GitManager`: TypeScript facade for the Rust engine lifecycle.
 - `GitManager.start()`: spawns the Rust binary through `smartrust` and starts the engine.
 - `GitManager.stop()`: asks the engine to stop and always kills the bridge process in cleanup.
 - `GitManager.getStatus()`: returns `{ running, dataDir, uptimeMs, smartHttp? }`.
+- `GitManager.checkReadiness()`: performs a bounded, cancellable read-only readiness probe and returns `{ ready, status, durationMs }` plus a failure `reason` when unavailable.
 - `GitManager.setSmartHttpRepositoryAccess()`: atomically replaces the running Smart HTTP allow-all/allowlist state.
 - `GitManager.setSmartHttpRepositoryVisibility()`: applies one revision-ordered repository visibility update.
 - `GitManager.setSmartHttpRepositoryProtectedRefs()`: applies a complete revision-fenced set of exact protected-head rules and returns its effective revision and digest.
@@ -223,7 +239,7 @@ The returned service counts request, response, and stderr bytes, runs with an is
 - `GitManager.refreshMirror()`: atomically fetches and verifies the configured mirror source.
 - `GitManager.verifyRepository()`: runs a strict full integrity check.
 - `GitManager.createRepositoryBundle()`: writes a bounded full Git bundle into `transferDir` and returns its temporary path and size.
-- `GitManager.createRepositoryArchive()`: writes a bounded deterministic exact-commit `tar.gz` archive into `transferDir` and returns its digest, size, and temporary path.
+- `GitManager.createRepositoryArchive()`: writes a bounded deterministic exact-commit `tar.gz` archive into `transferDir` and returns its digest, compressed size, extracted regular-file size, entry count, and temporary path.
 - `GitManager.restoreRepositoryBundle()`: validates and atomically restores a bounded bundle from `transferDir`.
 - `GitManager.openRepositoryService()`: opens a bounded upload-pack or protected receive-pack stream for an authenticated SSH-style ingress.
 - `GitManager.listRepositories()`: lists local repositories managed below the configured data directory.
@@ -237,7 +253,7 @@ The returned service counts request, response, and stderr bytes, runs with an is
 - `GitManager.getTag()`: reads one tag by exact name.
 - `GitManager.running`: local facade running state.
 - `RustGitManagerBridge`: lower-level typed bridge around `@push.rocks/smartrust`.
-- `IGitManagerOptions`, `IGitManagerStatus`, `IRustGitManagerConfig`, `IGitManagerProtectedRefRule`, `IGitManagerSmartHttpRepositoryProtectedRefs`, `TGitManagerProtectedRefsApplyStatus`, and `IGitManagerProtectedRefsApplyResult`: exported option, status, and protected-ref contracts.
+- `IGitManagerOptions`, `IGitManagerStatus`, `IGitManagerReadinessOptions`, `TGitManagerReadinessResult`, `TGitManagerReadinessFailureReason`, `IRustGitManagerConfig`, `IGitManagerProtectedRefRule`, `IGitManagerSmartHttpRepositoryProtectedRefs`, `TGitManagerProtectedRefsApplyStatus`, and `IGitManagerProtectedRefsApplyResult`: exported option, status, readiness, and protected-ref contracts.
 
 Repository/read DTO contracts are re-exported from the published `@foss.global/interfaces` package.
 
@@ -264,7 +280,7 @@ pnpm run test:rust
 pnpm run build
 ```
 
-`pnpm test` runs the `pretest` hook first, which builds the Rust binaries with `tsrust`, and then runs lifecycle, local mirror/read API, raw upload-pack/receive-pack preparation, clone/fetch denial, trusted receive-pack denial, explicit policy initialization, protected create/delete/non-fast-forward enforcement, inherited self-test hardening, restart replay, and real push tests through `smartrust`.
+`pnpm test` runs the `pretest` hook first, which builds the Rust binaries with `tsrust`, and then runs lifecycle, bounded readiness, local mirror/read API, raw upload-pack/receive-pack preparation, clone/fetch denial, trusted receive-pack denial, explicit policy initialization, protected create/delete/non-fast-forward enforcement, inherited self-test hardening, restart replay, and real push tests through `smartrust`.
 
 ## License and Legal Information
 

package/thirdparty.md

@@ -4,6 +4,7 @@ This package bundles Rust binaries in `dist_rust/`. Those binaries are built fro
 
 | Crate | Version | License |
 | --- | --- | --- |
+| adler2 | 2.0.1 | 0BSD OR MIT OR Apache-2.0 |
 | aho-corasick | 1.1.4 | MIT OR Unlicense |
 | anstream | 1.0.0 | Apache-2.0 OR MIT |
 | anstyle | 1.0.14 | Apache-2.0 OR MIT |
@@ -25,9 +26,11 @@ This package bundles Rust binaries in `dist_rust/`. Those binaries are built fro
 | clap_lex | 1.1.0 | Apache-2.0 OR MIT |
 | colorchoice | 1.0.5 | Apache-2.0 OR MIT |
 | cpufeatures | 0.2.17 | MIT OR Apache-2.0 |
+| crc32fast | 1.5.0 | MIT OR Apache-2.0 |
 | crypto-common | 0.1.7 | MIT OR Apache-2.0 |
 | digest | 0.10.7 | MIT OR Apache-2.0 |
 | errno | 0.3.14 | Apache-2.0 OR MIT |
+| flate2 | 1.1.9 | MIT OR Apache-2.0 |
 | form_urlencoded | 1.2.2 | Apache-2.0 OR MIT |
 | futures-channel | 0.3.33 | Apache-2.0 OR MIT |
 | futures-core | 0.3.33 | Apache-2.0 OR MIT |
@@ -54,6 +57,7 @@ This package bundles Rust binaries in `dist_rust/`. Those binaries are built fro
 | matchit | 0.8.4 | BSD-3-Clause AND MIT |
 | memchr | 2.8.2 | MIT OR Unlicense |
 | mime | 0.3.17 | Apache-2.0 OR MIT |
+| miniz_oxide | 0.8.9 | MIT OR Zlib OR Apache-2.0 |
 | mio | 1.2.1 | MIT |
 | nu-ansi-term | 0.50.3 | MIT |
 | once_cell | 1.21.4 | Apache-2.0 OR MIT |
@@ -78,6 +82,7 @@ This package bundles Rust binaries in `dist_rust/`. Those binaries are built fro
 | sha2 | 0.10.9 | MIT OR Apache-2.0 |
 | sharded-slab | 0.1.7 | MIT |
 | signal-hook-registry | 1.4.8 | Apache-2.0 OR MIT |
+| simd-adler32 | 0.3.10 | MIT |
 | slab | 0.4.12 | MIT |
 | smallvec | 1.15.2 | Apache-2.0 OR MIT |
 | socket2 | 0.6.4 | Apache-2.0 OR MIT |
@@ -106,3 +111,81 @@ This package bundles Rust binaries in `dist_rust/`. Those binaries are built fro
 | windows-link | 0.2.1 | Apache-2.0 OR MIT |
 | windows-sys | 0.61.2 | Apache-2.0 OR MIT |
 | zmij | 1.0.21 | MIT |
+
+## MIT Notices For Compression Dependencies
+
+### crc32fast 1.5.0
+
+MIT License
+
+Copyright (c) 2018 Sam Rijs, Alex Crichton and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+### flate2 1.1.9
+
+Copyright (c) 2014-2026 Alex Crichton
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+### simd-adler32 0.3.10
+
+MIT License
+
+Copyright (c) [2021] [Marvin Countryman]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@foss.global/gitmanager',
-  version: '1.4.0',
+  version: '1.6.0',
   description: 'Headless Git manager for the foss.global Git platform, with a TypeScript API and Rust engine.'
 }

package/ts/classes.gitmanager.ts

@@ -33,11 +33,20 @@ import type {
   IGitManagerTreeEntry,
   IGitManagerTreeRequest,
   IGitManagerOptions,
+  IGitManagerReadinessOptions,
   IRustGitManagerConfig,
+  TGitManagerReadinessFailureReason,
+  TGitManagerReadinessResult,
 } from './models.js';
 import { RustGitManagerBridge } from './rust-gitmanager-bridge.js';
 import { GitManagerRepositoryService } from './classes.repositoryservice.js';
 
+const readinessDefaultTimeoutMs = 2_000;
+const readinessMaximumTimeoutMs = 30_000;
+
+type TGitManagerReadinessAbortSource = 'caller' | 'deadline';
+type TGitManagerReadinessProbeOutcome = 'ready' | 'aborted' | 'unavailable';
+
 export class GitManager extends plugins.EventEmitter {
   private bridge = new RustGitManagerBridge();
   private started = false;
@@ -45,6 +54,10 @@ export class GitManager extends plugins.EventEmitter {
   private stopRequested = false;
   private config: IRustGitManagerConfig;
   private readonly repositoryServices = new Set<GitManagerRepositoryService>();
+  private lifecycleEpoch = 0;
+  private smartHttpProbeUrl: string | null = null;
+  private readonly activeReadinessControllers = new Set<AbortController>();
+  private managementStatusProbePromise: Promise<TGitManagerReadinessProbeOutcome> | null = null;
 
   constructor(optionsArg: IGitManagerOptions = {}) {
     super();
@@ -56,6 +69,9 @@ export class GitManager extends plugins.EventEmitter {
       transferDir: optionsArg.transferDir ?? plugins.path.join(dataDir, 'transfers'),
       maxBundleBytes: optionsArg.maxBundleBytes ?? 8 * 1024 * 1024 * 1024,
       maxArchiveBytes: optionsArg.maxArchiveBytes ?? 128 * 1024 * 1024,
+      maxArchiveExtractedBytes:
+        optionsArg.maxArchiveExtractedBytes ?? 64 * 1024 * 1024 * 1024,
+      maxArchiveEntries: optionsArg.maxArchiveEntries ?? 1_000_000,
       smartHttp: smartHttpOptions && smartHttpOptions.enabled !== false
         ? {
             bindAddress: smartHttpOptions.bindAddress ?? '127.0.0.1',
@@ -95,6 +111,9 @@ export class GitManager extends plugins.EventEmitter {
     };
     this.bridge.on('exit', (code: number | null, signal: string | null) => {
       this.started = false;
+      this.lifecycleEpoch++;
+      this.smartHttpProbeUrl = null;
+      this.abortActiveReadinessProbes();
       this.emit('exit', code, signal);
     });
     this.bridge.on('stderr', (line: string) => {
@@ -111,6 +130,7 @@ export class GitManager extends plugins.EventEmitter {
     }
 
     this.stopRequested = false;
+    this.lifecycleEpoch++;
     this.startPromise = this.startInternal();
     try {
       await this.startPromise;
@@ -121,6 +141,9 @@ export class GitManager extends plugins.EventEmitter {
 
   public async stop(): Promise<void> {
     this.stopRequested = true;
+    this.lifecycleEpoch++;
+    this.smartHttpProbeUrl = null;
+    this.abortActiveReadinessProbes();
     if (this.startPromise) {
       await this.startPromise.catch(() => undefined);
     }
@@ -149,6 +172,94 @@ export class GitManager extends plugins.EventEmitter {
     return this.bridge.getStatus();
   }
 
+  /**
+   * Performs a bounded, read-only probe to verify engine readiness. When Git
+   * Smart HTTP is configured, the probe uses its independent /healthz route so
+   * readiness stays available while the serial management loop is busy with a
+   * long-running command; otherwise a single-flight bounded getStatus round
+   * trip is used, which queues behind in-flight management commands.
+   */
+  public async checkReadiness(
+    optionsArg: IGitManagerReadinessOptions = {},
+  ): Promise<TGitManagerReadinessResult> {
+    const startedAt = performance.now();
+    const timeoutMs = optionsArg.timeoutMs ?? readinessDefaultTimeoutMs;
+    if (
+      !Number.isSafeInteger(timeoutMs) ||
+      timeoutMs <= 0 ||
+      timeoutMs > readinessMaximumTimeoutMs
+    ) {
+      throw new TypeError(
+        `Readiness timeoutMs must be a positive safe integer no greater than ${readinessMaximumTimeoutMs}.`,
+      );
+    }
+
+    const callerSignal = optionsArg.signal;
+    if (callerSignal?.aborted) {
+      return this.createReadinessFailure('aborted', startedAt);
+    }
+    const lifecycleReason = this.getReadinessLifecycleReason();
+    if (lifecycleReason) {
+      return this.createReadinessFailure(lifecycleReason, startedAt);
+    }
+
+    const lifecycleEpoch = this.lifecycleEpoch;
+    const readinessController = new AbortController();
+    let abortSource: TGitManagerReadinessAbortSource | undefined;
+    const abortForCaller = (): void => {
+      if (!abortSource) {
+        abortSource = 'caller';
+      }
+      readinessController.abort();
+    };
+    callerSignal?.addEventListener('abort', abortForCaller, { once: true });
+    const deadlineTimer = setTimeout(() => {
+      if (!abortSource) {
+        abortSource = 'deadline';
+      }
+      readinessController.abort();
+    }, timeoutMs);
+    this.activeReadinessControllers.add(readinessController);
+
+    let probeOutcome: TGitManagerReadinessProbeOutcome;
+    try {
+      probeOutcome = this.smartHttpProbeUrl
+        ? await this.probeSmartHttpHealth(
+            this.smartHttpProbeUrl,
+            readinessController.signal,
+          )
+        : await this.probeManagementStatus(readinessController.signal);
+    } finally {
+      clearTimeout(deadlineTimer);
+      callerSignal?.removeEventListener('abort', abortForCaller);
+      this.activeReadinessControllers.delete(readinessController);
+    }
+
+    if (this.lifecycleEpoch !== lifecycleEpoch) {
+      return this.createReadinessFailure(
+        this.getReadinessLifecycleReason() ?? 'unavailable',
+        startedAt,
+      );
+    }
+    if (probeOutcome === 'aborted') {
+      if (abortSource === 'caller') {
+        return this.createReadinessFailure('aborted', startedAt);
+      }
+      if (abortSource === 'deadline') {
+        return this.createReadinessFailure('timeout', startedAt);
+      }
+      return this.createReadinessFailure('unavailable', startedAt);
+    }
+    if (probeOutcome === 'unavailable') {
+      return this.createReadinessFailure('unavailable', startedAt);
+    }
+    return {
+      ready: true,
+      status: 'ready',
+      durationMs: performance.now() - startedAt,
+    };
+  }
+
   public async setSmartHttpRepositoryAccess(
     accessArg: IGitManagerSmartHttpRepositoryAccess,
   ): Promise<void> {
@@ -339,6 +450,7 @@ export class GitManager extends plugins.EventEmitter {
         throw new Error('GitManager start was cancelled');
       }
       this.started = true;
+      await this.captureSmartHttpProbeUrl();
     } catch (error) {
       this.bridge.kill();
       this.started = false;
@@ -346,6 +458,177 @@ export class GitManager extends plugins.EventEmitter {
     }
   }
 
+  private async captureSmartHttpProbeUrl(): Promise<void> {
+    if (!this.config.smartHttp) {
+      return;
+    }
+    try {
+      const status = await this.bridge.getStatus({ timeoutMs: 5_000 });
+      this.smartHttpProbeUrl = this.resolveSmartHttpProbeUrl(status);
+    } catch {
+      this.smartHttpProbeUrl = null;
+    }
+  }
+
+  private resolveSmartHttpProbeUrl(statusArg: IGitManagerStatus): string | null {
+    const smartHttpStatus = statusArg.smartHttp;
+    if (!smartHttpStatus?.running || !smartHttpStatus.baseUrl) {
+      return null;
+    }
+    let baseUrl: URL;
+    try {
+      baseUrl = new URL(smartHttpStatus.baseUrl);
+    } catch {
+      return null;
+    }
+    if (baseUrl.hostname === '0.0.0.0') {
+      baseUrl.hostname = '127.0.0.1';
+    } else if (baseUrl.hostname === '::' || baseUrl.hostname === '[::]') {
+      baseUrl.hostname = '[::1]';
+    }
+    const hostname = baseUrl.hostname;
+    const isLoopback =
+      hostname === 'localhost' ||
+      hostname === '::1' ||
+      hostname === '[::1]' ||
+      hostname.startsWith('127.');
+    if (!isLoopback) {
+      return null;
+    }
+    return baseUrl.origin;
+  }
+
+  private probeSmartHttpHealth(
+    probeUrlArg: string,
+    signalArg: AbortSignal,
+  ): Promise<TGitManagerReadinessProbeOutcome> {
+    return new Promise((resolve) => {
+      let settled = false;
+      let healthRequest: plugins.http.ClientRequest | undefined;
+      const settle = (outcomeArg: TGitManagerReadinessProbeOutcome): void => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        signalArg.removeEventListener('abort', abortProbe);
+        resolve(outcomeArg);
+      };
+      const abortProbe = (): void => {
+        healthRequest?.destroy();
+        settle('aborted');
+      };
+      signalArg.addEventListener('abort', abortProbe, { once: true });
+      if (signalArg.aborted) {
+        abortProbe();
+        return;
+      }
+      try {
+        healthRequest = plugins.http.request(
+          new URL('/healthz', probeUrlArg),
+          { method: 'GET', agent: false },
+          (response) => {
+            const outcome: TGitManagerReadinessProbeOutcome =
+              response.statusCode === 200 ? 'ready' : 'unavailable';
+            // The body is never needed; destroying immediately keeps a peer
+            // that stalls mid-body from retaining the socket indefinitely.
+            healthRequest?.destroy();
+            settle(outcome);
+          },
+        );
+        healthRequest.on('error', () => settle('unavailable'));
+        healthRequest.end();
+      } catch {
+        settle('unavailable');
+      }
+    });
+  }
+
+  private probeManagementStatus(
+    signalArg: AbortSignal,
+  ): Promise<TGitManagerReadinessProbeOutcome> {
+    if (!this.managementStatusProbePromise) {
+      const probeEpoch = this.lifecycleEpoch;
+      const managementProbe = this.bridge
+        .getStatus({ timeoutMs: readinessMaximumTimeoutMs })
+        .then(
+          (status): TGitManagerReadinessProbeOutcome => {
+            if (
+              this.lifecycleEpoch === probeEpoch &&
+              this.config.smartHttp &&
+              !this.smartHttpProbeUrl
+            ) {
+              this.smartHttpProbeUrl = this.resolveSmartHttpProbeUrl(status);
+            }
+            return status.running ? 'ready' : 'unavailable';
+          },
+          (): TGitManagerReadinessProbeOutcome => 'unavailable',
+        );
+      this.managementStatusProbePromise = managementProbe;
+      void managementProbe.finally(() => {
+        if (this.managementStatusProbePromise === managementProbe) {
+          this.managementStatusProbePromise = null;
+        }
+      });
+    }
+    const sharedProbe = this.managementStatusProbePromise;
+    return new Promise((resolve) => {
+      let settled = false;
+      const settle = (outcomeArg: TGitManagerReadinessProbeOutcome): void => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        signalArg.removeEventListener('abort', abortWait);
+        resolve(outcomeArg);
+      };
+      const abortWait = (): void => {
+        settle('aborted');
+      };
+      signalArg.addEventListener('abort', abortWait, { once: true });
+      if (signalArg.aborted) {
+        abortWait();
+        return;
+      }
+      void sharedProbe.then(settle);
+    });
+  }
+
+  private getReadinessLifecycleReason():
+    | Extract<
+        TGitManagerReadinessFailureReason,
+        'not_running' | 'starting' | 'stopping'
+      >
+    | undefined {
+    if (this.startPromise) {
+      return 'starting';
+    }
+    if (!this.running) {
+      return 'not_running';
+    }
+    if (this.stopRequested) {
+      return 'stopping';
+    }
+    return undefined;
+  }
+
+  private createReadinessFailure(
+    reasonArg: TGitManagerReadinessFailureReason,
+    startedAtArg: number,
+  ): TGitManagerReadinessResult {
+    return {
+      ready: false,
+      status: 'unavailable',
+      reason: reasonArg,
+      durationMs: performance.now() - startedAtArg,
+    };
+  }
+
+  private abortActiveReadinessProbes(): void {
+    for (const readinessController of [...this.activeReadinessControllers]) {
+      readinessController.abort();
+    }
+  }
+
   private assertRunning(): void {
     if (!this.running) {
       throw new Error('GitManager is not running');

package/ts/models.ts

@@ -81,6 +81,8 @@ export interface IGitManagerRepositoryArchive
   archivePath: string;
   sizeBytes: number;
   sha256: string;
+  extractedSizeBytes: number;
+  entryCount: number;
 }
 
 export interface IGitManagerRepositoryLfsPointer {
@@ -125,6 +127,8 @@ export interface IGitManagerOptions {
   transferDir?: string;
   maxBundleBytes?: number;
   maxArchiveBytes?: number;
+  maxArchiveExtractedBytes?: number;
+  maxArchiveEntries?: number;
   smartHttp?: IGitManagerSmartHttpOptions;
 }
 
@@ -159,6 +163,8 @@ export interface IRustGitManagerConfig {
   transferDir: string;
   maxBundleBytes: number;
   maxArchiveBytes: number;
+  maxArchiveExtractedBytes: number;
+  maxArchiveEntries: number;
   smartHttp?: IRustGitManagerSmartHttpConfig;
 }
 
@@ -176,6 +182,32 @@ export interface IGitManagerStatus {
   smartHttp?: IGitManagerSmartHttpStatus;
 }
 
+export interface IGitManagerReadinessOptions {
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+
+export type TGitManagerReadinessFailureReason =
+  | 'not_running'
+  | 'starting'
+  | 'stopping'
+  | 'aborted'
+  | 'timeout'
+  | 'unavailable';
+
+export type TGitManagerReadinessResult =
+  | {
+      ready: true;
+      status: 'ready';
+      durationMs: number;
+    }
+  | {
+      ready: false;
+      status: 'unavailable';
+      reason: TGitManagerReadinessFailureReason;
+      durationMs: number;
+    };
+
 export type {
   IGitManagerCommitDetail,
   IGitManagerCommitRequest,

package/ts/plugins.ts

@@ -1,11 +1,12 @@
 // node native scope
 import * as childProcess from 'node:child_process';
 import { EventEmitter } from 'node:events';
+import * as http from 'node:http';
 import * as path from 'node:path';
 import * as stream from 'node:stream';
 import * as url from 'node:url';
 
-export { childProcess, EventEmitter, path, stream, url };
+export { childProcess, EventEmitter, http, path, stream, url };
 
 // @push.rocks scope
 import * as smartrust from '@push.rocks/smartrust';

package/ts/rust-gitmanager-bridge.ts

@@ -134,8 +134,10 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     await this.bridge.sendCommand('stop', {});
   }
 
-  public async getStatus(): Promise<IGitManagerStatus> {
-    return this.bridge.sendCommand('getStatus', {});
+  public async getStatus(
+    optionsArg?: plugins.smartrust.IRustBridgeRequestOptions,
+  ): Promise<IGitManagerStatus> {
+    return this.bridge.sendCommand('getStatus', {}, optionsArg);
   }
 
   public async setSmartHttpRepositoryAccess(accessArg: IGitManagerSmartHttpRepositoryAccess): Promise<void> {
@@ -182,7 +184,19 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
   public async createRepositoryArchive(
     requestArg: IGitManagerRepositoryArchiveRequest,
   ): Promise<IGitManagerRepositoryArchive> {
-    return this.bridge.sendCommand('createRepositoryArchive', requestArg);
+    const result = await this.bridge.sendCommand('createRepositoryArchive', requestArg, {
+      timeoutMs: 65 * 60 * 1000,
+    });
+    for (const [field, value] of [
+      ['sizeBytes', result.sizeBytes],
+      ['extractedSizeBytes', result.extractedSizeBytes],
+      ['entryCount', result.entryCount],
+    ] as const) {
+      if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`Rust GitManager returned an invalid ${field}`);
+      }
+    }
+    return result;
   }
 
   public async prepareRepositoryService(