@foss.global/gitmanager 2.2.0 → 2.4.0

package/changelog.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 2026-10-14 - 2.4.0
+
+### Features
+
+- `pushRefs()` pushes leased ref updates to a remote as one atomic transaction, `setDefaultBranch()` points HEAD at an existing branch, and mirrors keep the source default branch.
+  - `pushRefs()` sends 1 to 1,000 distinct full ref updates in one `git push --atomic --porcelain`, each with `--force-with-lease=<ref>:<expectedOldObjectId>` (empty for a create) and an explicit refspec. Objects to push are checked locally before any connection; a missing one fails with `objectNotFound`.
+  - `applied` means every ref is `ok`; `rejected` means the remote refused the push and changed no ref, with a failed lease reported `stale`, an up-to-date ref `ok` and every other ref `rejected`. Any per-ref refusal returns `rejected`; the call throws only when the remote's answer does not say what it did. A remote without the `atomic` capability fails with `atomicPushUnsupported` and nothing is pushed.
+  - A ref that already holds its `newObjectId` is reported `ok` with `up to date` without its lease being checked; it is not changed, so `ok` never means the lease matched.
+  - The remote must be `https`, or `http` only to a loopback IP literal (`127.0.0.0/8`, `[::1]`); `localhost` and other names over `http`, user information and other schemes are refused before any process starts. The credential, CA certificates and `timeoutMs` work as for mirror imports, one deadline covers every Git command of a transfer, and transfer Git commands run untranslated.
+  - `refreshMirror()` now sets the mirror's HEAD to the source HEAD, which `git fetch` alone never moves; `setDefaultBranch()` refuses a missing branch and leaves HEAD unchanged.
+  - `pushRefs()` also accepts a credential over loopback `http` (`127.0.0.0/8` in canonical dotted-decimal form, exactly `[::1]`); such a transfer never uses an inherited `http_proxy`, `all_proxy` or `ALL_PROXY`, so the credential cannot leave the machine, while `https` transfers keep honouring proxies.
+  - `refreshMirror()` now fails before fetching when the source HEAD points outside `refs/heads/`.
+  - require @foss.global/interfaces ^2.1.0 for the atomic push and default branch contracts
+- Mirror transfers and pushes can be cancelled and run alongside other commands, and mirror transfers hold their repository against concurrent pushes.
+  - `importMirror()`, `refreshMirror()` and `pushRefs()` accept `{ signal }`: an abort ends the transfer's Git process group (SIGTERM, then SIGKILL after 5 s) and rejects with `transferAborted`. An aborted import leaves no repository, a push aborted before Git starts changes nothing, and the remote outcome of a push aborted later is unknown.
+  - A transfer that reaches its `timeoutMs` ends the same way, so Git removes its lock files and the next refresh is not blocked by a stale `*.lock`.
+  - Transfers run concurrently with other commands and with each other; `stop()` cancels running transfers and waits at most 15 s for them instead of queueing behind them.
+  - A mirror import or refresh holds its repository: other writes to it fail fast with `repositoryBusy`, and a Smart HTTP receive-pack into it answers 503 with `Retry-After`. While a Smart HTTP receive-pack into a repository runs, a mirror transfer of it is refused with `repositoryBusy`. The two used to race at Git level.
+  - `openRepositoryService()` returns a `guardTicketId` for a receive-pack whose Git process the embedder runs, such as an SSH push. Until `releaseRepositoryService(ticketId)` or engine stop, mirror transfers of that repository are refused with `repositoryBusy`; release it in a `finally` after the Git process exits. Releasing is idempotent, and upload-pack takes no ticket. The ticket ID is chosen before the engine is asked, so a receive-pack that fails to open, including one whose preparation timed out after the engine issued the ticket, has its ticket released before the error is thrown.
+
+## 2026-10-13 - 2.3.0
+
+### Features
+
+- Mirror imports and refreshes take a credential, CA certificates and a time limit. (mirror)
+  - `importMirror()` and `refreshMirror()` accept `credential: { kind: 'basic', username, password }`, `caCertificates` and `timeoutMs` (120000 by default, at most 21600000).
+  - The credential reaches Git only through the child process environment as an `Authorization` header; it never appears in the remote URL, the command line, the repository config or an error, and requires an `https` URL without user information. Redirects are not followed and global and system Git config are not read while it is carried.
+  - Imports now run with the refresh hardening: no credential helper, no hooks, no `ext::` transport, checked incoming objects. Transfer errors replace the remote URL with `<mirror-source>`.
+  - CA certificates are written to a private file in `transferDir` for the transfer; a file left by a killed engine is removed at the next start.
+- `getRepositorySize()` returns a repository's exact object count, uncompressed object bytes and object storage bytes. (size)
+
+### Maintenance
+
+- require @foss.global/interfaces ^2.0.0 for the mirror credential and repository size contracts (deps)
+- update release tooling: @git.zone/tsrust 4.5.1, pnpm 12.10.1 (deps)
+
 ## 2026-10-13 - 2.2.0
 
 ### Features

package/dist_rust/rustgitmanager_linux_amd64.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "4ae6faaef38693d41841c7cf28e2b5a2e1b7f21dc62216f51ff57f5226f3ce3f",
+  "binarySha256": "7044aaec06d25e4db40e40427ab71fe5e2484f4fa917979b1a6cf4b825dd233e",
   "buildInfo": {
     "projectName": "@foss.global/gitmanager",
-    "projectVersion": "2.2.0",
-    "gitCommit": "822f204f41b0c4dd1568bcc0ab3f39b2cac7dc24",
+    "projectVersion": "2.4.0",
+    "gitCommit": "a0731c48523953a4e3657025eab08f55196798b1",
     "gitDirty": false,
-    "builtAt": "2026-10-13T12:50:33.898Z",
-    "tsrustVersion": "4.3.0",
+    "builtAt": "2026-10-14T01:13:34.824Z",
+    "tsrustVersion": "4.5.1",
     "binary": "rustgitmanager",
     "target": "linux_amd64"
   }

package/dist_rust/rustgitmanager_linux_arm64.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "ee6df3157272f92f359d18e10afea6de37056b36d3f209e2c5e1da4bdbe3eea0",
+  "binarySha256": "0be71258153959cc0759a143903893fe56fb110935834a94eab6ae4ac5534c5b",
   "buildInfo": {
     "projectName": "@foss.global/gitmanager",
-    "projectVersion": "2.2.0",
-    "gitCommit": "822f204f41b0c4dd1568bcc0ab3f39b2cac7dc24",
+    "projectVersion": "2.4.0",
+    "gitCommit": "a0731c48523953a4e3657025eab08f55196798b1",
     "gitDirty": false,
-    "builtAt": "2026-10-13T12:52:52.510Z",
-    "tsrustVersion": "4.3.0",
+    "builtAt": "2026-10-14T01:14:46.956Z",
+    "tsrustVersion": "4.5.1",
     "binary": "rustgitmanager",
     "target": "linux_arm64"
   }

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@foss.global/gitmanager',
-    version: '2.2.0',
+    version: '2.4.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 { IGitManagerAncestryRequest, IGitManagerArchiveInspection, IGitManagerArchiveInspectionOptions, IGitManagerArchiveInspectionRequest, IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffRequest, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRefRequest, IGitManagerProtectedRefsApplyResult, IGitManagerSmartHttpRepositoryProtectedRefs, IGitManagerRepositoryBundle, IGitManagerRepositoryArchive, IGitManagerRepositoryArchiveOptions, IGitManagerRepositoryArchiveRequest, IGitManagerRepositoryLfsPointer, IGitManagerRepositoryServiceRequest, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerRestoreBundleRequest, IGitManagerSmartHttpRepositoryAccess, IGitManagerSmartHttpRepositoryVisibility, IGitManagerStatus, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, IGitManagerOptions, IGitManagerReadinessOptions, TGitManagerRefInventoryResult, TGitManagerReadinessResult } from './models.js';
+import type { IGitManagerAncestryRequest, IGitManagerAtomicPushRequest, IGitManagerAtomicPushResult, IGitManagerArchiveInspection, IGitManagerArchiveInspectionOptions, IGitManagerArchiveInspectionRequest, IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffRequest, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRefRequest, IGitManagerRefreshMirrorRequest, IGitManagerProtectedRefsApplyResult, IGitManagerSmartHttpRepositoryProtectedRefs, IGitManagerRepositoryBundle, IGitManagerRepositoryArchive, IGitManagerRepositoryArchiveOptions, IGitManagerRepositoryArchiveRequest, IGitManagerRepositoryLfsPointer, IGitManagerRepositoryServiceRequest, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerRepositorySize, IGitManagerRestoreBundleRequest, IGitManagerSetDefaultBranchRequest, IGitManagerSmartHttpRepositoryAccess, IGitManagerSmartHttpRepositoryVisibility, IGitManagerStatus, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, IGitManagerTransferControlOptions, IGitManagerOptions, IGitManagerReadinessOptions, TGitManagerRefInventoryResult, TGitManagerReadinessResult } from './models.js';
 import { GitManagerRepositoryService } from './classes.repositoryservice.js';
 export declare class GitManager extends plugins.EventEmitter {
     private bridge;
@@ -32,12 +32,101 @@ export declare class GitManager extends plugins.EventEmitter {
     setSmartHttpRepositoryProtectedRefs(protectedRefsArg: IGitManagerSmartHttpRepositoryProtectedRefs): Promise<IGitManagerProtectedRefsApplyResult>;
     get running(): boolean;
     initBareRepository(requestArg: IGitManagerInitBareRepositoryRequest): Promise<IGitManagerRepositoryInfo>;
-    importMirror(requestArg: IGitManagerImportMirrorRequest): Promise<IGitManagerRepositoryInfo>;
-    refreshMirror(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositoryInfo>;
+    /**
+     * Clones every ref of `remoteUrl` into a new mirror repository whose HEAD
+     * points at the source's default branch. Pass a credential as
+     * `credential`, never inside the URL: the engine hands it to Git only
+     * through the process environment and removes it from errors.
+     *
+     * The import runs alongside other commands and holds `org/repo` until it
+     * ends: another mirror transfer of it or a write to it (such as
+     * `initBareRepository` or `restoreRepositoryBundle`) fails with
+     * `repositoryBusy`. Aborting `optionsArg.signal`, or `stop()`, terminates
+     * the clone and removes the partial repository; the call then rejects with
+     * `transferAborted`, and no repository is left behind. An import whose
+     * clone already completed when the abort arrived returns its result.
+     */
+    importMirror(requestArg: IGitManagerImportMirrorRequest, optionsArg?: IGitManagerTransferControlOptions): Promise<IGitManagerRepositoryInfo>;
+    /**
+     * Fetches every ref of an imported mirror's remote again, with the same
+     * transfer options as `importMirror`, and points HEAD at the source's
+     * current default branch when the source advertises one.
+     *
+     * The refresh holds `org/repo` like `importMirror`: writes to it, including
+     * Smart HTTP pushes, are refused with `repositoryBusy` while it runs, and it
+     * is refused while such a write is in progress; reads proceed. Aborting
+     * `optionsArg.signal`, or `stop()`, terminates the fetch and rejects with
+     * `transferAborted`. The mirror's refs then stay as they were or, when the
+     * abort came after `git fetch --atomic` committed its ref transaction, are
+     * fully refreshed; HEAD moves only when the refresh completes.
+     */
+    refreshMirror(requestArg: IGitManagerRefreshMirrorRequest, optionsArg?: IGitManagerTransferControlOptions): Promise<IGitManagerRepositoryInfo>;
+    /**
+     * Pushes leased ref updates to `remoteUrl` as one atomic transaction: the
+     * remote applies all of them or none. The remote must advertise the
+     * `atomic` receive-pack capability; otherwise a `GitManagerError` with code
+     * `atomicPushUnsupported` is thrown and nothing is pushed. `remoteUrl` must
+     * be `https`, or `http` to a loopback IP address (`127.0.0.0/8`, `[::1]`;
+     * never a host name such as `localhost`), without user information; the
+     * credential travels as for `importMirror`. A ref that already holds its
+     * `newObjectId` is reported `ok` without its lease being checked; it is not
+     * changed, so `ok` never means the lease matched. Any refusal the remote
+     * reports per ref returns status `rejected`, with the refused refs `stale`
+     * or `rejected` and the up-to-date ones `ok`; the call throws only when the
+     * remote's answer does not say what it did.
+     *
+     * The push only reads the managed repository, so it runs alongside other
+     * commands and other transfers. Aborting `optionsArg.signal`, or `stop()`,
+     * rejects with `transferAborted`. An abort before `git push` starts (a
+     * signal already aborted, or an abort during the local object check)
+     * changes nothing on the remote. An abort while it runs terminates it, and
+     * the remote then holds all of the updates or none of them, unknown which:
+     * read the remote refs again before retrying.
+     */
+    pushRefs(requestArg: IGitManagerAtomicPushRequest, optionsArg?: IGitManagerTransferControlOptions): Promise<IGitManagerAtomicPushResult>;
+    /** Points the repository's HEAD at an existing branch; a missing branch is refused and HEAD stays unchanged. */
+    setDefaultBranch(requestArg: IGitManagerSetDefaultBranchRequest): Promise<IGitManagerRepositoryInfo>;
+    /** Counts the repository's objects and their exact Git bytes. */
+    getRepositorySize(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositorySize>;
     verifyRepository(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositoryInfo>;
     createRepositoryBundle(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositoryBundle>;
     createRepositoryArchive(requestArg: IGitManagerRepositoryArchiveRequest, optionsArg?: IGitManagerRepositoryArchiveOptions): Promise<IGitManagerRepositoryArchive>;
+    /**
+     * Starts a bounded `git upload-pack` or protected `git receive-pack` for an
+     * authenticated ingress such as SSH.
+     *
+     * A receive-pack holds its repository against mirror transfers: while its
+     * `guardTicketId` is held, `importMirror` and `refreshMirror` of the
+     * repository fail with `repositoryBusy`, and a receive-pack is refused with
+     * `repositoryBusy` while a mirror transfer runs. Release the ticket with
+     * `releaseRepositoryService()` in a `finally` once the process has exited
+     * and the push is reconciled; `stop()` releases every ticket. Upload-pack
+     * takes no ticket.
+     *
+     * The ticket ID is chosen here, before the engine is asked. When opening a
+     * receive-pack fails, including a bridge timeout after the engine already
+     * issued the ticket, the ticket is released before the error is thrown. If
+     * that release fails as well, the original error is still thrown: the
+     * release error becomes its `cause` when it has none, and otherwise both
+     * are thrown together as an `AggregateError` (`errors`: the original error,
+     * then the release error; `cause`: the original error).
+     */
     openRepositoryService(requestArg: IGitManagerRepositoryServiceRequest): Promise<GitManagerRepositoryService>;
+    /**
+     * Releases the guard ticket of a receive-pack that failed to open and
+     * returns the error to throw: `errorArg`, carrying a failed release as its
+     * `cause` when it has none, or else an `AggregateError` of both.
+     */
+    private releaseUnusedTicket;
+    /**
+     * Releases the guard ticket of a receive-pack opened with
+     * `openRepositoryService()` (`service.guardTicketId`), so mirror transfers
+     * of its repository are admitted again. Call it in a `finally` after the
+     * Git process has exited. Releasing is idempotent: an unknown or already
+     * released ticket, or a stopped engine, whose tickets ended with it, is a
+     * no-op.
+     */
+    releaseRepositoryService(ticketIdArg: string): Promise<void>;
     restoreRepositoryBundle(requestArg: IGitManagerRestoreBundleRequest): Promise<IGitManagerRepositoryInfo>;
     listRepositories(): Promise<IGitManagerRepositoryInfo[]>;
     /**

package/dist_ts/classes.gitmanager.js

@@ -4,6 +4,54 @@ import { GitManagerRepositoryService } from './classes.repositoryservice.js';
 import { runArchiveInspection } from './classes.archiveinspection.js';
 const readinessDefaultTimeoutMs = 2_000;
 const readinessMaximumTimeoutMs = 30_000;
+const remoteTransferMaximumTimeoutMs = 21_600_000;
+/**
+ * Checks transfer options before they reach the engine, which answers a
+ * malformed credential-bearing request with fixed text only. Messages never
+ * quote a credential value.
+ */
+const assertRemoteTransferOptions = (optionsArg) => {
+    const { credential, caCertificates, timeoutMs } = optionsArg;
+    if (credential !== undefined) {
+        if (credential === null
+            || typeof credential !== 'object'
+            || credential.kind !== 'basic'
+            || typeof credential.username !== 'string'
+            || typeof credential.password !== 'string'
+            || Object.keys(credential).some((key) => !['kind', 'username', 'password'].includes(key))) {
+            throw new TypeError('credential must be { kind: "basic", username: string, password: string }');
+        }
+    }
+    if (caCertificates !== undefined
+        && (!Array.isArray(caCertificates) || caCertificates.some((certificate) => typeof certificate !== 'string'))) {
+        throw new TypeError('caCertificates must be an array of PEM strings');
+    }
+    if (timeoutMs !== undefined
+        && (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > remoteTransferMaximumTimeoutMs)) {
+        throw new RangeError(`timeoutMs must be an integer between 1 and ${remoteTransferMaximumTimeoutMs}`);
+    }
+};
+/**
+ * Checks the shape of push updates before they reach the engine, which
+ * answers a malformed request with fixed text only. Ref names and object IDs
+ * are validated by the engine.
+ */
+const assertAtomicPushUpdates = (updatesArg) => {
+    const isObjectIdOrNull = (valueArg) => valueArg === null || typeof valueArg === 'string';
+    if (!Array.isArray(updatesArg)
+        || updatesArg.some((update) => {
+            if (update === null || typeof update !== 'object') {
+                return true;
+            }
+            const record = update;
+            return typeof record.ref !== 'string'
+                || !isObjectIdOrNull(record.expectedOldObjectId)
+                || !isObjectIdOrNull(record.newObjectId)
+                || Object.keys(record).some((key) => !['ref', 'expectedOldObjectId', 'newObjectId'].includes(key));
+        })) {
+        throw new TypeError('updates must be an array of { ref: string, expectedOldObjectId: string | null, newObjectId: string | null }');
+    }
+};
 export class GitManager extends plugins.EventEmitter {
     constructor(optionsArg = {}) {
         super();
@@ -253,13 +301,80 @@ export class GitManager extends plugins.EventEmitter {
         this.assertRunning();
         return this.bridge.initBareRepository(requestArg);
     }
-    async importMirror(requestArg) {
+    /**
+     * Clones every ref of `remoteUrl` into a new mirror repository whose HEAD
+     * points at the source's default branch. Pass a credential as
+     * `credential`, never inside the URL: the engine hands it to Git only
+     * through the process environment and removes it from errors.
+     *
+     * The import runs alongside other commands and holds `org/repo` until it
+     * ends: another mirror transfer of it or a write to it (such as
+     * `initBareRepository` or `restoreRepositoryBundle`) fails with
+     * `repositoryBusy`. Aborting `optionsArg.signal`, or `stop()`, terminates
+     * the clone and removes the partial repository; the call then rejects with
+     * `transferAborted`, and no repository is left behind. An import whose
+     * clone already completed when the abort arrived returns its result.
+     */
+    async importMirror(requestArg, optionsArg = {}) {
+        this.assertRunning();
+        assertRemoteTransferOptions(requestArg);
+        return this.bridge.importMirror(requestArg, optionsArg);
+    }
+    /**
+     * Fetches every ref of an imported mirror's remote again, with the same
+     * transfer options as `importMirror`, and points HEAD at the source's
+     * current default branch when the source advertises one.
+     *
+     * The refresh holds `org/repo` like `importMirror`: writes to it, including
+     * Smart HTTP pushes, are refused with `repositoryBusy` while it runs, and it
+     * is refused while such a write is in progress; reads proceed. Aborting
+     * `optionsArg.signal`, or `stop()`, terminates the fetch and rejects with
+     * `transferAborted`. The mirror's refs then stay as they were or, when the
+     * abort came after `git fetch --atomic` committed its ref transaction, are
+     * fully refreshed; HEAD moves only when the refresh completes.
+     */
+    async refreshMirror(requestArg, optionsArg = {}) {
         this.assertRunning();
-        return this.bridge.importMirror(requestArg);
+        assertRemoteTransferOptions(requestArg);
+        return this.bridge.refreshMirror(requestArg, optionsArg);
     }
-    async refreshMirror(requestArg) {
+    /**
+     * Pushes leased ref updates to `remoteUrl` as one atomic transaction: the
+     * remote applies all of them or none. The remote must advertise the
+     * `atomic` receive-pack capability; otherwise a `GitManagerError` with code
+     * `atomicPushUnsupported` is thrown and nothing is pushed. `remoteUrl` must
+     * be `https`, or `http` to a loopback IP address (`127.0.0.0/8`, `[::1]`;
+     * never a host name such as `localhost`), without user information; the
+     * credential travels as for `importMirror`. A ref that already holds its
+     * `newObjectId` is reported `ok` without its lease being checked; it is not
+     * changed, so `ok` never means the lease matched. Any refusal the remote
+     * reports per ref returns status `rejected`, with the refused refs `stale`
+     * or `rejected` and the up-to-date ones `ok`; the call throws only when the
+     * remote's answer does not say what it did.
+     *
+     * The push only reads the managed repository, so it runs alongside other
+     * commands and other transfers. Aborting `optionsArg.signal`, or `stop()`,
+     * rejects with `transferAborted`. An abort before `git push` starts (a
+     * signal already aborted, or an abort during the local object check)
+     * changes nothing on the remote. An abort while it runs terminates it, and
+     * the remote then holds all of the updates or none of them, unknown which:
+     * read the remote refs again before retrying.
+     */
+    async pushRefs(requestArg, optionsArg = {}) {
         this.assertRunning();
-        return this.bridge.refreshMirror(requestArg);
+        assertRemoteTransferOptions(requestArg);
+        assertAtomicPushUpdates(requestArg.updates);
+        return this.bridge.pushRefs(requestArg, optionsArg);
+    }
+    /** Points the repository's HEAD at an existing branch; a missing branch is refused and HEAD stays unchanged. */
+    async setDefaultBranch(requestArg) {
+        this.assertRunning();
+        return this.bridge.setDefaultBranch(requestArg);
+    }
+    /** Counts the repository's objects and their exact Git bytes. */
+    async getRepositorySize(requestArg) {
+        this.assertRunning();
+        return this.bridge.getRepositorySize(requestArg);
     }
     async verifyRepository(requestArg) {
         this.assertRunning();
@@ -273,27 +388,98 @@ export class GitManager extends plugins.EventEmitter {
         this.assertRunning();
         return this.bridge.createRepositoryArchive(requestArg, optionsArg);
     }
+    /**
+     * Starts a bounded `git upload-pack` or protected `git receive-pack` for an
+     * authenticated ingress such as SSH.
+     *
+     * A receive-pack holds its repository against mirror transfers: while its
+     * `guardTicketId` is held, `importMirror` and `refreshMirror` of the
+     * repository fail with `repositoryBusy`, and a receive-pack is refused with
+     * `repositoryBusy` while a mirror transfer runs. Release the ticket with
+     * `releaseRepositoryService()` in a `finally` once the process has exited
+     * and the push is reconciled; `stop()` releases every ticket. Upload-pack
+     * takes no ticket.
+     *
+     * The ticket ID is chosen here, before the engine is asked. When opening a
+     * receive-pack fails, including a bridge timeout after the engine already
+     * issued the ticket, the ticket is released before the error is thrown. If
+     * that release fails as well, the original error is still thrown: the
+     * release error becomes its `cause` when it has none, and otherwise both
+     * are thrown together as an `AggregateError` (`errors`: the original error,
+     * then the release error; `cause`: the original error).
+     */
     async openRepositoryService(requestArg) {
         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 guardTicketId = requestArg.service === 'receive-pack'
+            ? plugins.crypto.randomUUID()
+            : undefined;
+        let service;
+        try {
+            const descriptor = await this.bridge.prepareRepositoryService({
+                org: requestArg.org,
+                repo: requestArg.repo,
+                service: requestArg.service,
+                ...(requestArg.protocol ? { protocol: requestArg.protocol } : {}),
+                ...(guardTicketId === undefined ? {} : { guardTicketId }),
+            });
+            if (this.lifecycleEpoch !== serviceEpoch
+                || this.stopRequested
+                || !this.running) {
+                throw new Error('GitManager stopped while preparing repository service');
+            }
+            if (descriptor.guardTicketId !== guardTicketId) {
+                throw new Error('GitManager returned an invalid repository service descriptor');
+            }
+            service = new GitManagerRepositoryService(descriptor, requestArg, this.config.dataDir);
+        }
+        catch (error) {
+            if (guardTicketId === undefined) {
+                throw error;
+            }
+            throw await this.releaseUnusedTicket(guardTicketId, error);
         }
-        const service = new GitManagerRepositoryService(descriptor, requestArg, this.config.dataDir);
         this.repositoryServices.add(service);
         service.completed.finally(() => {
             this.repositoryServices.delete(service);
         }).catch(() => undefined);
         return service;
     }
+    /**
+     * Releases the guard ticket of a receive-pack that failed to open and
+     * returns the error to throw: `errorArg`, carrying a failed release as its
+     * `cause` when it has none, or else an `AggregateError` of both.
+     */
+    async releaseUnusedTicket(ticketIdArg, errorArg) {
+        try {
+            await this.releaseRepositoryService(ticketIdArg);
+            return errorArg;
+        }
+        catch (releaseError) {
+            if (errorArg instanceof Error && errorArg.cause === undefined) {
+                errorArg.cause = releaseError;
+                return errorArg;
+            }
+            return new AggregateError([errorArg, releaseError], 'Opening the repository service failed, and releasing its guard ticket failed', { cause: errorArg });
+        }
+    }
+    /**
+     * Releases the guard ticket of a receive-pack opened with
+     * `openRepositoryService()` (`service.guardTicketId`), so mirror transfers
+     * of its repository are admitted again. Call it in a `finally` after the
+     * Git process has exited. Releasing is idempotent: an unknown or already
+     * released ticket, or a stopped engine, whose tickets ended with it, is a
+     * no-op.
+     */
+    async releaseRepositoryService(ticketIdArg) {
+        if (typeof ticketIdArg !== 'string') {
+            throw new TypeError('ticketId must be a string');
+        }
+        if (!this.bridge.running) {
+            return;
+        }
+        await this.bridge.releaseRepositoryService(ticketIdArg);
+    }
     async restoreRepositoryBundle(requestArg) {
         this.assertRunning();
         return this.bridge.restoreRepositoryBundle(requestArg);
@@ -585,4 +771,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/classes.gitmanagererror.js

@@ -5,6 +5,9 @@ const gitManagerErrorCodes = new Set([
     'ancestryBudgetExceeded',
     'archiveLimitExceeded',
     'archiveRejected',
+    'atomicPushUnsupported',
+    'transferAborted',
+    'repositoryBusy',
 ]);
 export const isGitManagerErrorCode = (valueArg) => typeof valueArg === 'string' && gitManagerErrorCodes.has(valueArg);
 /**
@@ -19,4 +22,4 @@ export class GitManagerError extends Error {
         this.code = codeArg;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5naXRtYW5hZ2VyZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLmdpdG1hbmFnZXJlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLG9CQUFvQixHQUF3QixJQUFJLEdBQUcsQ0FBdUI7SUFDOUUsaUJBQWlCO0lBQ2pCLGdCQUFnQjtJQUNoQixpQkFBaUI7SUFDakIsd0JBQXdCO0lBQ3hCLHNCQUFzQjtJQUN0QixpQkFBaUI7Q0FDbEIsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsQ0FBQyxRQUFpQixFQUFvQyxFQUFFLENBQzNGLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxvQkFBb0IsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7QUFFckU7Ozs7R0FJRztBQUNILE1BQU0sT0FBTyxlQUFnQixTQUFRLEtBQUs7SUFHeEMsWUFBWSxPQUE2QixFQUFFLFVBQWtCLEVBQUUsVUFBeUI7UUFDdEYsS0FBSyxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUM5QixJQUFJLENBQUMsSUFBSSxHQUFHLGlCQUFpQixDQUFDO1FBQzlCLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDO0lBQ3RCLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5naXRtYW5hZ2VyZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLmdpdG1hbmFnZXJlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLG9CQUFvQixHQUF3QixJQUFJLEdBQUcsQ0FBdUI7SUFDOUUsaUJBQWlCO0lBQ2pCLGdCQUFnQjtJQUNoQixpQkFBaUI7SUFDakIsd0JBQXdCO0lBQ3hCLHNCQUFzQjtJQUN0QixpQkFBaUI7SUFDakIsdUJBQXVCO0lBQ3ZCLGlCQUFpQjtJQUNqQixnQkFBZ0I7Q0FDakIsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsQ0FBQyxRQUFpQixFQUFvQyxFQUFFLENBQzNGLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxvQkFBb0IsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7QUFFckU7Ozs7R0FJRztBQUNILE1BQU0sT0FBTyxlQUFnQixTQUFRLEtBQUs7SUFHeEMsWUFBWSxPQUE2QixFQUFFLFVBQWtCLEVBQUUsVUFBeUI7UUFDdEYsS0FBSyxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUM5QixJQUFJLENBQUMsSUFBSSxHQUFHLGlCQUFpQixDQUFDO1FBQzlCLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDO0lBQ3RCLENBQUM7Q0FDRiJ9

package/dist_ts/classes.repositoryservice.d.ts

@@ -5,6 +5,15 @@ export declare class GitManagerRepositoryService {
     readonly stdout: plugins.stream.Readable;
     readonly stderr: plugins.stream.Readable;
     readonly completed: Promise<IGitManagerRepositoryServiceResult>;
+    /**
+     * Receive-pack only: the guard ticket that holds the repository against
+     * mirror transfers (`importMirror`, `refreshMirror`, which fail with
+     * `repositoryBusy`) until `GitManager.releaseRepositoryService()` releases
+     * it or the engine stops. Release it in a `finally` once the process has
+     * exited and the push is reconciled. A UUID that `openRepositoryService()`
+     * chose. Null for upload-pack.
+     */
+    readonly guardTicketId: string | null;
     private readonly child;
     private completionSettled;
     private failure;