@foss.global/gitmanager 1.5.0 → 1.7.0

package/dist_ts/rust-gitmanager-bridge.js

@@ -46,6 +46,9 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     kill() {
         this.bridge.kill();
     }
+    async terminate() {
+        await this.bridge.terminate();
+    }
     get running() {
         return this.bridge.running;
     }
@@ -55,8 +58,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);
@@ -82,10 +85,50 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     async createRepositoryBundle(requestArg) {
         return this.bridge.sendCommand('createRepositoryBundle', requestArg);
     }
-    async createRepositoryArchive(requestArg) {
-        const result = await this.bridge.sendCommand('createRepositoryArchive', requestArg, {
+    async createRepositoryArchive(requestArg, optionsArg = {}) {
+        if (optionsArg.signal?.aborted) {
+            throw optionsArg.signal.reason ?? new Error('Repository archive creation was aborted.');
+        }
+        const operationId = plugins.crypto.randomUUID();
+        const archivePromise = this.bridge.sendCommand('createRepositoryArchive', {
+            operationId,
+            request: requestArg,
+        }, {
             timeoutMs: 65 * 60 * 1000,
         });
+        let cancelPromise;
+        const cancelArchive = () => {
+            cancelPromise ??= this.bridge.sendCommand('cancelRepositoryArchive', {
+                operationId,
+            }, {
+                timeoutMs: 65 * 60 * 1000,
+            });
+        };
+        optionsArg.signal?.addEventListener('abort', cancelArchive, { once: true });
+        if (optionsArg.signal?.aborted) {
+            cancelArchive();
+        }
+        let result;
+        try {
+            result = await archivePromise;
+            if (cancelPromise) {
+                await cancelPromise.catch(() => undefined);
+            }
+        }
+        catch (archiveError) {
+            if (!cancelPromise) {
+                throw archiveError;
+            }
+            const cancellation = await cancelPromise;
+            if (cancellation.status === 'cancelled') {
+                throw optionsArg.signal?.reason
+                    ?? new Error('Repository archive creation was aborted.');
+            }
+            throw archiveError;
+        }
+        finally {
+            optionsArg.signal?.removeEventListener('abort', cancelArchive);
+        }
         for (const [field, value] of [
             ['sizeBytes', result.sizeBytes],
             ['extractedSizeBytes', result.extractedSizeBytes],
@@ -137,4 +180,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,{"version":3,"file":"rust-gitmanager-bridge.js","sourceRoot":"","sources":["../ts/rust-gitmanager-bridge.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foss.global/gitmanager",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "private": false,
   "description": "Headless Git manager for the foss.global Git platform, with a TypeScript API and Rust engine.",
   "exports": {
@@ -11,16 +11,16 @@
   "license": "MIT",
   "dependencies": {
     "@foss.global/interfaces": "^0.11.0",
-    "@push.rocks/smartrust": "^1.5.0"
+    "@push.rocks/smartrust": "^1.7.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.6",
-    "@git.zone/tsrust": "^1.7.0",
-    "@git.zone/tstest": "^3.6.7",
-    "@types/node": "^26.1.1"
+    "@git.zone/tsrust": "^1.8.0",
+    "@git.zone/tstest": "^4.0.0",
+    "@types/node": "^26.2.0"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -76,6 +76,8 @@ await gitManager.restoreRepositoryBundle({
 
 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.
 
+Pass `{ signal }` as the second argument to `createRepositoryArchive()` to cancel archive creation. GitManager keeps operation IDs private, terminates and reaps active Git or inspection subprocesses, removes partial staging files, and only then rejects with the caller's abort reason. If final archive publication wins the cancellation race, the method returns the completed archive. `stop()` is single-flight and uses the same cleanup barrier before confirmed bridge termination.
+
 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
@@ -211,12 +213,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. Repository archive creation also keeps management status and cancellation responsive while preserving serial admission for every other stateful command. 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 other 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.stop()`: shares one in-flight stop, cancels and cleans active archives, then confirms bridge process termination.
 - `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.
@@ -225,7 +241,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, compressed size, extracted regular-file size, entry count, and temporary path.
+- `GitManager.createRepositoryArchive(request, { signal? })`: 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; cancellation settles after Rust process and staging cleanup.
 - `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.
@@ -239,7 +255,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.
 
@@ -266,7 +282,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/ts/00_commitinfo_data.ts

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

package/ts/classes.gitmanager.ts

@@ -19,6 +19,7 @@ import type {
   IGitManagerSmartHttpRepositoryProtectedRefs,
   IGitManagerRepositoryBundle,
   IGitManagerRepositoryArchive,
+  IGitManagerRepositoryArchiveOptions,
   IGitManagerRepositoryArchiveRequest,
   IGitManagerRepositoryLfsPointer,
   IGitManagerRepositoryServiceRequest,
@@ -33,18 +34,32 @@ 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;
   private startPromise: Promise<void> | null = null;
   private stopRequested = false;
+  private stopPromise: Promise<void> | null = null;
   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();
@@ -98,6 +113,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) => {
@@ -112,8 +130,12 @@ export class GitManager extends plugins.EventEmitter {
     if (this.startPromise) {
       throw new Error('GitManager is already starting');
     }
+    if (this.stopPromise) {
+      throw new Error('GitManager is stopping');
+    }
 
     this.stopRequested = false;
+    this.lifecycleEpoch++;
     this.startPromise = this.startInternal();
     try {
       await this.startPromise;
@@ -122,13 +144,31 @@ export class GitManager extends plugins.EventEmitter {
     }
   }
 
-  public async stop(): Promise<void> {
+  public stop(): Promise<void> {
+    if (this.stopPromise) {
+      return this.stopPromise;
+    }
+    const stopPromise = this.stopInternal();
+    this.stopPromise = stopPromise;
+    void stopPromise.finally(() => {
+      if (this.stopPromise === stopPromise) {
+        this.stopPromise = null;
+      }
+    }).catch(() => undefined);
+    return stopPromise;
+  }
+
+  private async stopInternal(): Promise<void> {
     this.stopRequested = true;
+    this.lifecycleEpoch++;
+    this.smartHttpProbeUrl = null;
+    this.abortActiveReadinessProbes();
     if (this.startPromise) {
       await this.startPromise.catch(() => undefined);
     }
     if (!this.bridge.running) {
       await this.closeRepositoryServices();
+      await this.bridge.terminate();
       this.started = false;
       return;
     }
@@ -136,7 +176,7 @@ export class GitManager extends plugins.EventEmitter {
       await this.closeRepositoryServices();
       await this.bridge.stopGitManager();
     } finally {
-      this.bridge.kill();
+      await this.bridge.terminate();
       this.started = false;
     }
   }
@@ -152,6 +192,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> {
@@ -227,21 +355,30 @@ export class GitManager extends plugins.EventEmitter {
 
   public async createRepositoryArchive(
     requestArg: IGitManagerRepositoryArchiveRequest,
+    optionsArg: IGitManagerRepositoryArchiveOptions = {},
   ): Promise<IGitManagerRepositoryArchive> {
     this.assertRunning();
-    return this.bridge.createRepositoryArchive(requestArg);
+    return this.bridge.createRepositoryArchive(requestArg, optionsArg);
   }
 
   public async openRepositoryService(
     requestArg: IGitManagerRepositoryServiceRequest,
   ): Promise<GitManagerRepositoryService> {
     this.assertRunning();
+    const serviceEpoch = this.lifecycleEpoch;
     const descriptor = await this.bridge.prepareRepositoryService({
       org: requestArg.org,
       repo: requestArg.repo,
       service: requestArg.service,
       ...(requestArg.protocol ? { protocol: requestArg.protocol } : {}),
     });
+    if (
+      this.lifecycleEpoch !== serviceEpoch
+      || this.stopRequested
+      || !this.running
+    ) {
+      throw new Error('GitManager stopped while preparing repository service');
+    }
     const service = new GitManagerRepositoryService(
       descriptor,
       requestArg,
@@ -326,7 +463,7 @@ export class GitManager extends plugins.EventEmitter {
       throw new Error('Failed to spawn rustgitmanager binary');
     }
     if (this.stopRequested) {
-      this.bridge.kill();
+      await this.bridge.terminate();
       throw new Error('GitManager start was cancelled');
     }
 
@@ -336,20 +473,195 @@ export class GitManager extends plugins.EventEmitter {
         try {
           await this.bridge.stopGitManager();
         } finally {
-          this.bridge.kill();
+          await this.bridge.terminate();
           this.started = false;
         }
         throw new Error('GitManager start was cancelled');
       }
       this.started = true;
+      await this.captureSmartHttpProbeUrl();
     } catch (error) {
-      this.bridge.kill();
+      await this.bridge.terminate();
       this.started = false;
       throw error;
     }
   }
 
+  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.stopRequested) {
+      throw new Error('GitManager is stopping');
+    }
     if (!this.running) {
       throw new Error('GitManager is not running');
     }