@foss.global/gitmanager 2.3.0 → 2.5.0

package/dist_ts/classes.repositoryservice.js

@@ -42,12 +42,15 @@ const validateDescriptor = (descriptorArg, requestArg) => {
         if (!descriptorArg.hookPath
             || !plugins.path.isAbsolute(descriptorArg.hookPath)
             || !descriptorArg.protectedRefsPolicy
-            || !/^[A-Za-z0-9_-]{1,65536}$/.test(descriptorArg.protectedRefsPolicy)) {
+            || !/^[A-Za-z0-9_-]{1,65536}$/.test(descriptorArg.protectedRefsPolicy)
+            || typeof descriptorArg.guardTicketId !== 'string'
+            || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(descriptorArg.guardTicketId)) {
             throw new Error('GitManager returned an invalid receive-pack descriptor');
         }
     }
     else if (descriptorArg.hookPath !== undefined
-        || descriptorArg.protectedRefsPolicy !== undefined) {
+        || descriptorArg.protectedRefsPolicy !== undefined
+        || descriptorArg.guardTicketId !== undefined) {
         throw new Error('GitManager returned unexpected upload-pack hook state');
     }
 };
@@ -56,6 +59,7 @@ export class GitManagerRepositoryService {
         this.completionSettled = false;
         this.failure = null;
         validateDescriptor(descriptorArg, requestArg);
+        this.guardTicketId = descriptorArg.guardTicketId ?? null;
         const args = descriptorArg.service === 'upload-pack'
             ? [
                 'upload-pack',
@@ -190,4 +194,4 @@ export class GitManagerRepositoryService {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.repositoryservice.js","sourceRoot":"","sources":["../ts/classes.repositoryservice.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.repositoryservice.js","sourceRoot":"","sources":["../ts/classes.repositoryservice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAQxC,MAAM,kBAAmB,SAAQ,OAAO,CAAC,MAAM,CAAC,SAAS;IAGvD,YACmB,YAAoB,EACpB,KAAa,EACb,OAAmB;QAEpC,KAAK,EAAE,CAAC;QAJS,iBAAY,GAAZ,YAAY,CAAQ;QACpB,UAAK,GAAL,KAAK,CAAQ;QACb,YAAO,GAAP,OAAO,CAAY;QAL9B,UAAK,GAAG,CAAC,CAAC;IAQlB,CAAC;IAEQ,UAAU,CACjB,QAAsC,EACtC,WAA2B,EAC3B,WAA6C;QAE7C,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;YACrC,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,OAAO,QAAQ,KAAK,QAAQ;gBAC5B,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC;gBACpC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,UAAU,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YACxE,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,WAAW,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,GAAG,qCAAqC,CAAC,CAAC,CAAC;YAC3E,OAAO;QACT,CAAC;QACD,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC3B,CAAC;CACF;AAED,MAAM,kBAAkB,GAAG,CACzB,aAAyD,EACzD,UAA+C,EACzC,EAAE;IACR,IACE,aAAa,CAAC,GAAG,KAAK,UAAU,CAAC,GAAG;WACjC,aAAa,CAAC,IAAI,KAAK,UAAU,CAAC,IAAI;WACtC,aAAa,CAAC,OAAO,KAAK,UAAU,CAAC,OAAO;WAC5C,aAAa,CAAC,QAAQ,KAAK,UAAU,CAAC,QAAQ;WAC9C,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC;WACtD,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,eAAe,CAAC;WACpD,aAAa,CAAC,eAAe,GAAG,IAAI;WACpC,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,gBAAgB,CAAC;WACrD,aAAa,CAAC,gBAAgB,GAAG,IAAI,GAAG,IAAI;WAC5C,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,gBAAgB,CAAC;WACrD,aAAa,CAAC,gBAAgB,GAAG,IAAI;WACrC,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,kBAAkB,CAAC;WACvD,aAAa,CAAC,kBAAkB,GAAG,CAAC,EACvC,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IAClF,CAAC;IACD,IAAI,aAAa,CAAC,OAAO,KAAK,cAAc,EAAE,CAAC;QAC7C,IACE,CAAC,aAAa,CAAC,QAAQ;eACpB,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC;eAChD,CAAC,aAAa,CAAC,mBAAmB;eAClC,CAAC,0BAA0B,CAAC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC;eACnE,OAAO,aAAa,CAAC,aAAa,KAAK,QAAQ;eAC/C,CAAC,gEAAgE,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,EACtG,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;IACH,CAAC;SAAM,IACL,aAAa,CAAC,QAAQ,KAAK,SAAS;WACjC,aAAa,CAAC,mBAAmB,KAAK,SAAS;WAC/C,aAAa,CAAC,aAAa,KAAK,SAAS,EAC5C,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC3E,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,OAAO,2BAA2B;IAmBtC,YACE,aAAyD,EACzD,UAA+C,EAC/C,gBAAwB;QAPlB,sBAAiB,GAAG,KAAK,CAAC;QAC1B,YAAO,GAA+C,IAAI,CAAC;QAQjE,kBAAkB,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;QAC9C,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC,aAAa,IAAI,IAAI,CAAC;QACzD,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,KAAK,aAAa;YAClD,CAAC,CAAC;gBACE,aAAa;gBACb,UAAU;gBACV,WAAW;gBACX,MAAM,CAAC,aAAa,CAAC,kBAAkB,CAAC;gBACxC,aAAa,CAAC,cAAc;aAC7B;YACH,CAAC,CAAC;gBACE,IAAI;gBACJ,iBAAiB,GAAG,aAAa,CAAC,QAAS;gBAC3C,IAAI;gBACJ,0BAA0B;gBAC1B,cAAc;gBACd,aAAa,CAAC,cAAc;aAC7B,CAAC;QACN,MAAM,WAAW,GAAsB;YACrC,IAAI,EAAE,gBAAgB;YACtB,IAAI,EAAE,GAAG;YACT,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,8BAA8B;YACxD,WAAW,EAAE,MAAM;YACnB,iBAAiB,EAAE,WAAW;YAC9B,mBAAmB,EAAE,GAAG;YACxB,iBAAiB,EAAE,GAAG;YACtB,mBAAmB,EAAE,GAAG;YACxB,eAAe,EAAE,OAAO;YACxB,WAAW,EAAE,MAAM;YACnB,GAAG,CAAC,aAAa,CAAC,QAAQ;gBACxB,CAAC,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,QAAQ,EAAE;gBAC1C,CAAC,CAAC,EAAE,CAAC;YACP,GAAG,CAAC,aAAa,CAAC,mBAAmB;gBACnC,CAAC,CAAC;oBACE,gCAAgC,EAC9B,aAAa,CAAC,mBAAmB;iBACpC;gBACH,CAAC,CAAC,EAAE,CAAC;SACR,CAAC;QACF,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE;YACnD,QAAQ,EAAE,OAAO,CAAC,QAAQ,KAAK,OAAO;YACtC,GAAG,EAAE,WAAW;YAChB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YAC/B,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,CAAC,UAA+C,EAAE,EAAE,CACnE,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC9B,MAAM,KAAK,GAAG,IAAI,kBAAkB,CAClC,aAAa,CAAC,eAAe,EAC7B,gCAAgC,EAChC,QAAQ,CAAC,sBAAsB,CAAC,CACjC,CAAC;QACF,MAAM,MAAM,GAAG,IAAI,kBAAkB,CACnC,aAAa,CAAC,gBAAgB,EAC9B,iCAAiC,EACjC,QAAQ,CAAC,uBAAuB,CAAC,CAClC,CAAC;QACF,MAAM,MAAM,GAAG,IAAI,kBAAkB,CACnC,GAAG,GAAG,IAAI,EACV,+BAA+B,EAC/B,QAAQ,CAAC,qBAAqB,CAAC,CAChC,CAAC;QACF,sEAAsE;QACtE,uEAAuE;QACvE,mEAAmE;QACnE,kEAAkE;QAClE,KAAK,MAAM,WAAW,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;YACxF,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC9C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC7B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC/C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;gBACjC,IAAI,IAAI,CAAC,iBAAiB;oBAAE,OAAO;gBACnC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;gBAC9B,IAAI,CAAC,YAAY,EAAE,CAAC;gBACpB,MAAM,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE;gBAC5C,IAAI,IAAI,CAAC,iBAAiB;oBAAE,OAAO;gBACnC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;gBAC9B,IAAI,CAAC,YAAY,EAAE,CAAC;gBACpB,OAAO,CAAC;oBACN,QAAQ;oBACR,MAAM,EAAE,MAA+B;oBACvC,OAAO,EAAE,IAAI,CAAC,OAAO;iBACtB,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;YAC7B,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC9B,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;QACnC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;IAEM,SAAS;QACd,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAChD,OAAO;QACT,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;QAC3B,IAAI,GAAG,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YACxC,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;gBAC9B,OAAO;YACT,CAAC;YAAC,MAAM,CAAC;gBACP,yCAAyC;YAC3C,CAAC;QACH,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,KAAK;QAChB,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACrB,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,KAAK,MAAM,WAAW,IAAI;YACxB,IAAI,CAAC,MAAM;YACX,IAAI,CAAC,MAAM;YACX,IAAI,CAAC,KAAK,CAAC,MAAM;YACjB,IAAI,CAAC,KAAK,CAAC,MAAM;SAClB,EAAE,CAAC;YACF,WAAW,CAAC,OAAO,EAAE,CAAC;QACxB,CAAC;QACD,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED,qEAAqE;IAC7D,IAAI,CAAC,UAA+C;QAC1D,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC7C,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;QAC5B,CAAC;QACD,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAEO,YAAY;QAClB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC3B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QAC3B,CAAC;IACH,CAAC;CACF"}

package/dist_ts/models.d.ts

@@ -59,6 +59,14 @@ export interface IGitManagerRepositoryArchiveRequest extends IGitManagerReposito
 export interface IGitManagerRepositoryArchiveOptions {
     signal?: AbortSignal;
 }
+/**
+ * Call options of the remote transfers `importMirror`, `refreshMirror` and
+ * `pushRefs`. Aborting `signal` stops the transfer; the call then rejects
+ * with a `GitManagerError` whose code is `transferAborted`.
+ */
+export interface IGitManagerTransferControlOptions {
+    signal?: AbortSignal;
+}
 export interface IGitManagerRepositoryArchive extends IGitManagerRepositorySelector {
     objectId: string;
     archivePath: string;
@@ -119,8 +127,17 @@ export interface IGitManagerArchiveInspection {
  *   answer is unknown, never `false`.
  * - `archiveLimitExceeded`: the archive exceeds a requested limit.
  * - `archiveRejected`: the archive breaks a format, path, or link rule.
+ * - `atomicPushUnsupported`: the push remote does not advertise the `atomic`
+ *   receive-pack capability; nothing was pushed.
+ * - `remoteLimitExceeded`: the push remote refused the push request as too
+ *   large (HTTP 413); nothing was pushed.
+ * - `transferAborted`: a remote transfer was aborted through its `signal` or
+ *   by `stop()`. An aborted push may or may not have been applied by the
+ *   remote; read its refs again.
+ * - `repositoryBusy`: a mirror transfer holds the repository, or a write to
+ *   it is in progress when a mirror transfer starts; nothing was changed.
  */
-export type TGitManagerErrorCode = 'invalidObjectId' | 'objectNotFound' | 'objectNotCommit' | 'ancestryBudgetExceeded' | 'archiveLimitExceeded' | 'archiveRejected';
+export type TGitManagerErrorCode = 'invalidObjectId' | 'objectNotFound' | 'objectNotCommit' | 'ancestryBudgetExceeded' | 'archiveLimitExceeded' | 'archiveRejected' | 'atomicPushUnsupported' | 'remoteLimitExceeded' | 'transferAborted' | 'repositoryBusy';
 export interface IGitManagerRepositoryLfsPointer {
     oid: string;
     sizeBytes: number;
@@ -130,6 +147,15 @@ export interface IGitManagerRepositoryServiceRequest extends IGitManagerReposito
     service: TGitManagerRepositoryService;
     protocol?: 'version=0' | 'version=1' | 'version=2';
 }
+/**
+ * The engine request that prepares a repository service. A receive-pack
+ * carries the guard ticket ID the facade chose, so the facade can release the
+ * ticket even when it never receives the engine's answer.
+ */
+export interface IRustGitManagerRepositoryServicePrepareRequest extends IGitManagerRepositoryServiceRequest {
+    /** Receive-pack only, and required there: a lowercase hyphenated UUID. */
+    guardTicketId?: string;
+}
 export interface IRustGitManagerRepositoryServiceDescriptor extends IGitManagerRepositoryServiceRequest {
     repositoryPath: string;
     hookPath?: string;
@@ -138,6 +164,8 @@ export interface IRustGitManagerRepositoryServiceDescriptor extends IGitManagerR
     maxResponseBytes: number;
     processTimeoutMs: number;
     idleTimeoutSeconds: number;
+    /** Receive-pack only: the requested guard ticket ID, which `releaseRepositoryService` releases. */
+    guardTicketId?: string;
 }
 /**
  * Why GitManager terminated a repository service process. The value says the
@@ -226,4 +254,4 @@ export type TGitManagerReadinessResult = {
     reason: TGitManagerReadinessFailureReason;
     durationMs: number;
 };
-export type { IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffFile, IGitManagerDiffHunk, IGitManagerDiffLine, IGitManagerDiffRequest, IGitManagerDiffStats, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRef, IGitManagerRefHead, IGitManagerRefInventoryPage, IGitManagerRefInventoryStale, IGitManagerRefRequest, IGitManagerRefreshMirrorRequest, IGitManagerRemoteBasicCredential, IGitManagerRemoteTransferOptions, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerRepositorySize, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, TGitManagerDiffFileStatus, TGitManagerDiffLineKind, TGitManagerMergeMethod, TGitManagerMergeStatus, TGitManagerObjectType, TGitManagerRefInventoryPagination, TGitManagerRefInventoryResult, TGitManagerRemoteCredential, TGitManagerTreeEntryType, } from '@foss.global/interfaces';
+export type { IGitManagerAtomicPushRefResult, IGitManagerAtomicPushRefUpdate, IGitManagerAtomicPushRequest, IGitManagerAtomicPushResult, IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffFile, IGitManagerDiffHunk, IGitManagerDiffLine, IGitManagerDiffRequest, IGitManagerDiffStats, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRef, IGitManagerRefHead, IGitManagerRefInventoryPage, IGitManagerRefInventoryStale, IGitManagerRefRequest, IGitManagerRefreshMirrorRequest, IGitManagerRemoteBasicCredential, IGitManagerRemoteTransferOptions, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerRepositorySize, IGitManagerSetDefaultBranchRequest, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, TGitManagerAtomicPushRefStatus, TGitManagerDiffFileStatus, TGitManagerDiffLineKind, TGitManagerMergeMethod, TGitManagerMergeStatus, TGitManagerObjectType, TGitManagerRefInventoryPagination, TGitManagerRefInventoryResult, TGitManagerRemoteCredential, TGitManagerTreeEntryType, } from '@foss.global/interfaces';

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

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import type { IGitManagerAncestryRequest, 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, IGitManagerSmartHttpRepositoryAccess, IGitManagerSmartHttpRepositoryVisibility, IGitManagerStatus, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, IRustGitManagerConfig, TGitManagerRefInventoryResult, IRustGitManagerRepositoryServiceDescriptor } from './models.js';
+import type { IGitManagerAncestryRequest, IGitManagerAtomicPushRequest, IGitManagerAtomicPushResult, IGitManagerCommitDetail, IGitManagerCommitRequest, IGitManagerCommitSummary, IGitManagerDiff, IGitManagerDiffRequest, IGitManagerFileContent, IGitManagerImportMirrorRequest, IGitManagerInitBareRepositoryRequest, IGitManagerListCommitsRequest, IGitManagerListTagsRequest, IGitManagerMergeRequest, IGitManagerMergeResult, IGitManagerReadFileRequest, IGitManagerRefRequest, IGitManagerRefreshMirrorRequest, IGitManagerProtectedRefsApplyResult, IGitManagerSmartHttpRepositoryProtectedRefs, IGitManagerRepositoryBundle, IGitManagerRepositoryArchive, IGitManagerRepositoryArchiveOptions, IGitManagerRepositoryArchiveRequest, IGitManagerRepositoryLfsPointer, IGitManagerRepositoryInfo, IGitManagerRepositorySelector, IGitManagerRepositorySize, IGitManagerRestoreBundleRequest, IGitManagerSetDefaultBranchRequest, IGitManagerSmartHttpRepositoryAccess, IGitManagerSmartHttpRepositoryVisibility, IGitManagerStatus, IGitManagerTag, IGitManagerTagRequest, IGitManagerTreeEntry, IGitManagerTreeRequest, IGitManagerTransferControlOptions, IRustGitManagerConfig, TGitManagerRefInventoryResult, IRustGitManagerRepositoryServiceDescriptor, IRustGitManagerRepositoryServicePrepareRequest } from './models.js';
 export declare class RustGitManagerBridge extends plugins.EventEmitter {
     private bridge;
     private binaryLocator;
@@ -17,13 +17,24 @@ export declare class RustGitManagerBridge extends plugins.EventEmitter {
     setSmartHttpRepositoryVisibility(visibilityArg: IGitManagerSmartHttpRepositoryVisibility): Promise<void>;
     setSmartHttpRepositoryProtectedRefs(protectedRefsArg: IGitManagerSmartHttpRepositoryProtectedRefs): Promise<IGitManagerProtectedRefsApplyResult>;
     initBareRepository(requestArg: IGitManagerInitBareRepositoryRequest): Promise<IGitManagerRepositoryInfo>;
-    importMirror(requestArg: IGitManagerImportMirrorRequest): Promise<IGitManagerRepositoryInfo>;
-    refreshMirror(requestArg: IGitManagerRefreshMirrorRequest): Promise<IGitManagerRepositoryInfo>;
+    importMirror(requestArg: IGitManagerImportMirrorRequest, optionsArg?: IGitManagerTransferControlOptions): Promise<IGitManagerRepositoryInfo>;
+    refreshMirror(requestArg: IGitManagerRefreshMirrorRequest, optionsArg?: IGitManagerTransferControlOptions): Promise<IGitManagerRepositoryInfo>;
+    pushRefs(requestArg: IGitManagerAtomicPushRequest, optionsArg?: IGitManagerTransferControlOptions): Promise<IGitManagerAtomicPushResult>;
+    /**
+     * Runs a remote transfer under a fresh operation ID. Aborting the signal
+     * sends `cancelTransfer`; the engine then terminates the transfer's Git
+     * process and answers the transfer itself with `transferAborted`. A signal
+     * that is already aborted rejects before anything is sent.
+     */
+    private runTransfer;
+    setDefaultBranch(requestArg: IGitManagerSetDefaultBranchRequest): Promise<IGitManagerRepositoryInfo>;
     getRepositorySize(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositorySize>;
     verifyRepository(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositoryInfo>;
     createRepositoryBundle(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositoryBundle>;
     createRepositoryArchive(requestArg: IGitManagerRepositoryArchiveRequest, optionsArg?: IGitManagerRepositoryArchiveOptions): Promise<IGitManagerRepositoryArchive>;
-    prepareRepositoryService(requestArg: IGitManagerRepositoryServiceRequest): Promise<IRustGitManagerRepositoryServiceDescriptor>;
+    prepareRepositoryService(requestArg: IRustGitManagerRepositoryServicePrepareRequest): Promise<IRustGitManagerRepositoryServiceDescriptor>;
+    /** Releases a receive-pack guard ticket; unknown or released tickets are a no-op. */
+    releaseRepositoryService(ticketIdArg: string): Promise<void>;
     restoreRepositoryBundle(requestArg: IGitManagerRestoreBundleRequest): Promise<IGitManagerRepositoryInfo>;
     listRepositories(): Promise<IGitManagerRepositoryInfo[]>;
     listRefs(requestArg: IGitManagerRefRequest): Promise<TGitManagerRefInventoryResult>;

package/dist_ts/rust-gitmanager-bridge.js

@@ -7,6 +7,8 @@ const defaultRemoteTransferTimeoutMs = 120_000;
  * a timeout and cleans up before the request is abandoned.
  */
 const remoteTransferResponseTimeoutMs = (timeoutMsArg) => (timeoutMsArg ?? defaultRemoteTransferTimeoutMs) + 30_000;
+/** The cancel command is answered at once; the transfer reports its own end. */
+const transferCancelTimeoutMs = 30_000;
 function getPackageRoot() {
     const thisDir = plugins.path.dirname(plugins.url.fileURLToPath(import.meta.url));
     return plugins.path.resolve(thisDir, '..');
@@ -104,17 +106,54 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
         return this.bridge.sendCommand('setSmartHttpRepositoryProtectedRefs', protectedRefsArg);
     }
     async initBareRepository(requestArg) {
-        return this.bridge.sendCommand('initBareRepository', requestArg);
-    }
-    async importMirror(requestArg) {
-        return this.bridge.sendCommand('importMirror', requestArg, {
+        return this.bridge.sendCommand('initBareRepository', requestArg).catch(rethrowCodedError);
+    }
+    async importMirror(requestArg, optionsArg = {}) {
+        return this.runTransfer('importMirror', requestArg, optionsArg);
+    }
+    async refreshMirror(requestArg, optionsArg = {}) {
+        return this.runTransfer('refreshMirror', requestArg, optionsArg);
+    }
+    async pushRefs(requestArg, optionsArg = {}) {
+        return this.runTransfer('pushRefs', requestArg, optionsArg);
+    }
+    /**
+     * Runs a remote transfer under a fresh operation ID. Aborting the signal
+     * sends `cancelTransfer`; the engine then terminates the transfer's Git
+     * process and answers the transfer itself with `transferAborted`. A signal
+     * that is already aborted rejects before anything is sent.
+     */
+    async runTransfer(methodArg, requestArg, optionsArg) {
+        const signal = optionsArg.signal;
+        if (signal?.aborted) {
+            throw new GitManagerError('transferAborted', 'The transfer was aborted before it started', {
+                cause: signal.reason,
+            });
+        }
+        const operationId = plugins.crypto.randomUUID();
+        const params = { operationId, request: requestArg };
+        const transfer = this.bridge.sendCommand(methodArg, params, {
             timeoutMs: remoteTransferResponseTimeoutMs(requestArg.timeoutMs),
         });
+        const cancelTransfer = () => {
+            // Only the transfer's own response settles the call.
+            void this.bridge.sendCommand('cancelTransfer', { operationId }, {
+                timeoutMs: transferCancelTimeoutMs,
+            }).catch(() => undefined);
+        };
+        signal?.addEventListener('abort', cancelTransfer, { once: true });
+        try {
+            return await transfer;
+        }
+        catch (error) {
+            return rethrowCodedError(error);
+        }
+        finally {
+            signal?.removeEventListener('abort', cancelTransfer);
+        }
     }
-    async refreshMirror(requestArg) {
-        return this.bridge.sendCommand('refreshMirror', requestArg, {
-            timeoutMs: remoteTransferResponseTimeoutMs(requestArg.timeoutMs),
-        });
+    async setDefaultBranch(requestArg) {
+        return this.bridge.sendCommand('setDefaultBranch', requestArg).catch(rethrowCodedError);
     }
     async getRepositorySize(requestArg) {
         // The engine measures for up to 30 minutes.
@@ -184,10 +223,14 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
         return result;
     }
     async prepareRepositoryService(requestArg) {
-        return this.bridge.sendCommand('prepareRepositoryService', requestArg);
+        return this.bridge.sendCommand('prepareRepositoryService', requestArg).catch(rethrowCodedError);
+    }
+    /** Releases a receive-pack guard ticket; unknown or released tickets are a no-op. */
+    async releaseRepositoryService(ticketIdArg) {
+        await this.bridge.sendCommand('releaseRepositoryService', { ticketId: ticketIdArg });
     }
     async restoreRepositoryBundle(requestArg) {
-        return this.bridge.sendCommand('restoreRepositoryBundle', requestArg);
+        return this.bridge.sendCommand('restoreRepositoryBundle', requestArg).catch(rethrowCodedError);
     }
     async listRepositories() {
         return this.bridge.sendCommand('listRepositories', {});
@@ -199,7 +242,7 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
         return this.bridge.sendCommand('listRepositoryLfsPointers', requestArg);
     }
     async mergeRepository(requestArg) {
-        return this.bridge.sendCommand('mergeRepository', requestArg);
+        return this.bridge.sendCommand('mergeRepository', requestArg).catch(rethrowCodedError);
     }
     async listTree(requestArg) {
         return this.bridge.sendCommand('listTree', requestArg);
@@ -236,4 +279,4 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
         return this.bridge.sendCommand('getTag', requestArg);
     }
 }
-//# 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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"}
+//# 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": "2.3.0",
+  "version": "2.5.0",
   "private": false,
   "description": "Headless Git manager for the foss.global Git platform, with a TypeScript API and Rust engine.",
   "exports": {
@@ -10,7 +10,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "dependencies": {
-    "@foss.global/interfaces": "^2.0.0",
+    "@foss.global/interfaces": "^2.1.0",
     "@push.rocks/smartrust": "^1.7.0"
   },
   "devDependencies": {

package/readme.md

@@ -127,10 +127,64 @@ const size = await gitManager.getRepositorySize({ org: 'mirror.org', repo: 'inte
 - The credential reaches Git only through the child process environment (`GIT_CONFIG_COUNT` entries) as an `Authorization: Basic` header. It never appears in the remote URL, on a command line, in the repository's Git config or in an error: error text replaces the remote URL with `<mirror-source>` and every form of the credential with `<redacted>`.
 - A credential requires an `https://` remote URL without user information. While it carries one, Git does not follow redirects and reads no global or system Git config, so `insteadOf` rewrites and credential helpers there cannot take effect.
 - `caCertificates` replaces Git's CA bundle for this transfer. The PEMs are written to a private file in `transferDir` that is removed when the transfer ends.
-- `timeoutMs` is the transfer's wall-clock limit: 120000 by default, at most 21600000 (six hours). The Git process group is killed when it runs out.
+- `timeoutMs` is the transfer's wall-clock limit: 120000 by default, at most 21600000 (six hours). When it runs out, the Git process group is ended like an abort: `SIGTERM` first, so Git removes the ref lock files it holds and the next transfer is not blocked by them, then `SIGKILL` after five seconds.
 - Both transfers run without credential helpers or hooks, refuse the `ext::` transport and check incoming objects.
+- The imported repository's HEAD points at the source's default branch, as `git clone --mirror` sets it. `git fetch` never moves HEAD, so `refreshMirror()` reads the source HEAD with `git ls-remote --symref` before it fetches and points the mirror's HEAD at the same branch afterwards. A source that advertises no symbolic HEAD (a detached HEAD) leaves the mirror's HEAD unchanged; a source HEAD outside `refs/heads/` fails the refresh before anything is fetched. Read the result back from the returned `defaultBranch` or from `listRefs()` (`head.symbolicTarget`).
+- Proxies: a transfer to a loopback `http` URL (`127.0.0.0/8`, `[::1]`) always connects directly. GitManager sets an empty `http.proxy` for it, so an inherited `http_proxy`, `all_proxy` or `ALL_PROXY` never receives the plain request or its `Authorization` header. `https` transfers keep honouring the proxy settings: a proxy only tunnels them (`CONNECT`), and the header stays inside TLS.
 - `getRepositorySize()` counts the distinct objects of the repository's own object database (`objectCount`) and the sum of their uncompressed sizes (`objectBytes`), which does not depend on packing. `storageBytes` is the size of every file below `objects/`. A repository with alternate object stores is refused. Measuring runs for at most 30 minutes.
 
+### Cancellation, concurrency and stop
+
+`importMirror()`, `refreshMirror()` and `pushRefs()` take `{ signal }` as their second argument:
+
+```ts
+const controller = new AbortController();
+const refreshing = gitManager.refreshMirror({ org: 'mirror.org', repo: 'interfaces', credential }, { signal: controller.signal });
+controller.abort();
+await refreshing; // rejects with GitManagerError, code 'transferAborted'
+```
+
+- Aborting the signal terminates the transfer's Git process (`SIGTERM`, so Git removes its lock files, then `SIGKILL` after five seconds) and waits for it to exit before the call rejects with a `GitManagerError` whose code is `transferAborted`. A signal that is already aborted rejects before anything reaches the engine. A transfer that completed before the abort reached the engine returns its result. `timeoutMs` still applies.
+- An aborted `importMirror()` leaves no repository behind: the partial clone and the CA bundle file are removed, as after any failed import.
+- An aborted `refreshMirror()` leaves the mirror's refs as they were or, when the abort came after `git fetch --atomic` committed its ref transaction, fully refreshed; HEAD moves only when the refresh completes. `git fetch` writes and checks all objects before it updates the refs and never deletes objects. With Git 2.43, `--prune` deletions are part of the same `--atomic` ref transaction: when one ref update fails (observed with a foreign lock file on one ref, for packed and for loose refs), no ref is updated and no ref is pruned. The transaction commits by renaming lock files one by one, so an abort landing inside that commit (the same window as a crash) can leave some refs updated or pruned; every ref then points at a complete object, and the next refresh converges.
+- Transfers run as engine tasks next to the management channel: other commands, such as `getStatus()`, `listRepositories()` or a command on another repository, complete while a transfer is slow, and several transfers run at once. While an archive is being created, new transfers are refused like every other command, as before.
+- A mirror transfer holds its repository until it ends. Another mirror transfer of it, a write to it (`initBareRepository()`, `restoreRepositoryBundle()`, `setDefaultBranch()`, `mergeRepository()`, receive-pack preparation in `openRepositoryService()`) and a Smart HTTP push into it are refused at once: the methods throw a `GitManagerError` with code `repositoryBusy`, and Smart HTTP answers `503 repository busy` with `Retry-After`. A mirror transfer is refused the same way while a Smart HTTP push into its repository runs. Before 2.4.0 a Smart HTTP push and a refresh of the same repository raced at Git level, each failing on the other's ref locks or overwriting its result. A receive-pack opened through `openRepositoryService()` (for SSH) holds its repository the same way until it is released; see [Raw Git services for SSH ingress](#raw-git-services-for-ssh-ingress). Reads (`listRefs()`, `readFile()`, `getRepositorySize()`, `verifyRepository()`, bundles, archives, clones and fetches over Smart HTTP) proceed and see the refs before or after the refresh. `pushRefs()` only reads its repository and holds nothing.
+- `stop()` does not wait behind transfers: it cancels every running transfer, waits for their Git processes to exit (at most 15 seconds), then stops the engine. Each cancelled transfer rejects with `transferAborted`. A transfer still running after the 15 seconds is dropped: its Git process group is killed and an import's partial repository is removed as the dropped import ends, so no temporary directory stays behind. Ending a Git process takes at most ten seconds, so this only happens when the host cannot reap it.
+
+## Atomic pushes and the default branch
+
+`pushRefs()` pushes ref updates from a managed repository to a remote as one atomic transaction (`IGitManagerAtomicPushRequest` from `@foss.global/interfaces`):
+
+```ts
+const result = await gitManager.pushRefs({
+  org: 'mirror.org',
+  repo: 'interfaces',
+  remoteUrl: 'https://git.example/foss.global/interfaces.git',
+  credential: { kind: 'basic', username: 'importer', password: pushToken },
+  caCertificates: [privateCaPem],
+  timeoutMs: 30 * 60 * 1000,
+  updates: [
+    { ref: 'refs/heads/main', expectedOldObjectId: null, newObjectId: mainOid }, // create
+    { ref: 'refs/tags/v1.0.0', expectedOldObjectId: oldTagOid, newObjectId: tagOid }, // move
+    { ref: 'refs/heads/old', expectedOldObjectId: oldOid, newObjectId: null }, // delete
+  ],
+});
+// { org, repo, status: 'applied' | 'rejected', refs: [{ ref, status: 'ok' | 'rejected' | 'stale', message? }] }
+
+await gitManager.setDefaultBranch({ org: 'mirror.org', repo: 'interfaces', defaultBranch: 'main' });
+```
+
+- `pushRefs()` drives Git's HTTP remote helper (`git remote-https`, or `git remote-http` for a loopback remote) over its standard input. It lists the remote's refs, checks every lease against that listing (`expectedOldObjectId: null` for a create, so the ref must not exist), and sends all updates in one atomic receive-pack request, one `<old> <new> <ref>` command per ref (a delete has no new object). The remote checks each old object again inside its atomic ref transaction, so a ref that moves between the listing and the push fails the whole push. Command lines keep the same size however many updates a push holds. A lease replaces the fast-forward rule, so a leased update may rewind or move a tag.
+- `applied` means every ref is `ok`. `rejected` means the remote refused the push and changed no ref: a ref whose lease failed is `stale`, a ref that already holds its `newObjectId` is `ok` (`up to date`, see below), and every other ref is `rejected` (`atomic push failed`, or the remote's reason). Any refusal the remote reports per ref returns `rejected`. `pushRefs()` throws only when it cannot tell what the remote did: a transport failure, a missing or unreadable ref status, an outcome that is neither, such as a partial update, a remote without the `atomic` capability, or a push request the remote refused as too large.
+- Git sends nothing for a ref that already holds `newObjectId`, whatever its lease says, and reports it `ok` with the message `up to date`, so a retried push whose first response was lost reads as `applied`. Such a ref is not changed, but its lease was not checked either: `ok` never means the lease matched. Deleting a ref that is already gone is `stale`.
+- The remote must advertise the `atomic` receive-pack capability. Without it Git refuses before it sends anything, and `pushRefs()` throws a `GitManagerError` with code `atomicPushUnsupported`; it never falls back to ref-by-ref updates.
+- Each `newObjectId` must be in the managed repository; a missing one throws a `GitManagerError` with code `objectNotFound` before any connection. A push holds one or more updates of distinct full ref names under `refs/`; object IDs are full lowercase hexadecimal. GitManager sets no upper bound and never splits a push. A remote that refuses the push request as too large (HTTP 413) makes `pushRefs()` throw a `GitManagerError` with code `remoteLimitExceeded`; nothing was pushed.
+- URL policy, enforced by GitManager: `https://`, or `http://` only to a loopback IP literal in its canonical spelling, `127.0.0.0/8` as four decimal octets without leading zeros or exactly `[::1]`. Other spellings of a loopback address (an uppercase scheme, octal, hexadecimal or single-integer forms, a trailing dot, other IPv6 forms) are refused rather than normalized, so Git receives exactly the URL the policy checked. Host names over `http`, `localhost` included, are refused, because a credential sent over plain `http` to a name would go wherever that name resolves. `ssh://`, `git://`, `file://`, `ext::`, local paths, scp-like URLs and URLs with user information are refused. The policy runs before any process starts, and its errors never quote the URL.
+- The credential, `caCertificates` and `timeoutMs` behave as for mirrors: the credential travels only in the Git process environment as an `Authorization` header, with no credential helper, no hooks, no redirects and no global or system Git config; error text replaces the remote URL with `<push-remote>`. The remote URL is never stored in the repository.
+- `{ signal }` aborts a push as described in [Cancellation, concurrency and stop](#cancellation-concurrency-and-stop). An abort before the updates are sent (the signal already aborted, or an abort during the local object check or the remote ref listing) changes nothing anywhere. An abort after that rejects with `transferAborted` as well, but the remote may have applied the push: the remote applies an atomic push completely or not at all, and the abort can land before or after it did. Read the remote refs again before retrying.
+- A loopback `http` push never goes through a proxy, so the credential cannot leave the machine; see the proxy note above.
+- `setDefaultBranch()` points HEAD at `refs/heads/<defaultBranch>` and returns the repository info. The branch name is given without `refs/heads/`; a branch that does not exist is refused and HEAD stays unchanged. A mirror's next `refreshMirror()` points HEAD at the source's default branch again.
+
 ## Durable repository bundles
 
 GitManager can export a repository as a full Git bundle and atomically restore it under a new managed repository identity. Bundle bytes never pass through JSON IPC: Rust writes or reads a temporary file inside the dedicated `transferDir`, and the caller streams that file to or from durable object storage.
@@ -191,7 +245,7 @@ console.log(status.smartHttp?.baseUrl);
 
 The server implements `git-upload-pack` for clone and fetch with Git protocol versions 0, 1, and 2. Missing and inaccessible read repositories both return the same not-found response. Configuring `privateRead` lets an authenticated loopback ingress grant repository-scoped access by injecting the exact `X-GitManager-Ingress-Token` value after removing any client-supplied copy. Direct private requests still receive the same not-found response.
 
-Configuring `receivePack` enables streamed push only for requests carrying the trusted ingress token. Private reads and receive-pack require a loopback bind even when `allowUnsafeNonLoopback` is set. The trusted ingress must authorize the user and repository; for pushes it must also serialize writes, persist the updated repository, and withhold success if persistence fails.
+Configuring `receivePack` enables streamed push only for requests carrying the trusted ingress token. A push into a repository that an `importMirror()` or `refreshMirror()` holds is answered `503 repository busy` with `Retry-After`, and a mirror transfer of a repository is refused with `repositoryBusy` while a push into it runs; before 2.4.0 the two raced at Git level. See [Cancellation, concurrency and stop](#cancellation-concurrency-and-stop). Private reads and receive-pack require a loopback bind even when `allowUnsafeNonLoopback` is set. The trusted ingress must authorize the user and repository; for pushes it must also serialize writes, persist the updated repository, and withhold success if persistence fails.
 
 The transport does not terminate TLS or implement user identity. Keep it behind a bounded ingress. Read-only binding to a non-loopback IP is rejected unless `allowUnsafeNonLoopback: true` is set explicitly.
 
@@ -281,6 +335,19 @@ When enabled, `getStatus().smartHttp` reports `{ running, bindAddress, port, bas
 
 `openRepositoryService()` starts a bounded local `git upload-pack` or protected `git receive-pack` process for an already authenticated ingress. Rust validates the repository selector, canonical path, Git protocol version, receive-pack availability, and immutable protected-ref policy snapshot before the TypeScript facade starts the process. Pack bytes use Node streams and never pass through JSON IPC.
 
+A receive-pack holds its repository against mirror transfers with a guard ticket, `service.guardTicketId`: while it is held, `importMirror()` and `refreshMirror()` of that repository fail with `repositoryBusy`, and preparing a receive-pack fails with `repositoryBusy` while a mirror transfer of the repository runs. The ticket outlives the Git process, so the repository stays held until the push is reconciled. Release it with `releaseRepositoryService()` in a `finally` once the process has exited and the push is reconciled; releasing is idempotent, and `stop()` releases every ticket. Upload-pack takes no ticket. Callers that never run mirror transfers on the repository see no difference.
+
+`openRepositoryService()` chooses the ticket ID, a UUID, before it asks the engine, and the engine holds the ticket under that ID. When opening a receive-pack fails, including a bridge timeout after the engine already issued the ticket, `openRepositoryService()` releases the ticket before it rejects, so a failed open never leaves the repository held. If that release fails too, the original error is still the one thrown and carries the release error as its `cause`; an original error that already has a `cause` is thrown as an `AggregateError` of both instead (`errors`: original, then release error; `cause`: original).
+
+```ts
+const service = await gitManager.openRepositoryService({ org: 'foss.global', repo: 'gitmanager', service: 'receive-pack' });
+try {
+  // pipe the SSH channel, await service.completed, reconcile the refs
+} finally {
+  await gitManager.releaseRepositoryService(service.guardTicketId!);
+}
+```
+
 ```ts
 const service = await gitManager.openRepositoryService({
   org: 'foss.global',
@@ -308,7 +375,7 @@ if (!readiness.ready) {
 }
 ```
 
-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`.
+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 repository bundle. Remote transfers (`importMirror()`, `refreshMirror()`, `pushRefs()`) do not occupy the channel. 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`.
 
 ## Commit ancestry
 
@@ -347,7 +414,7 @@ The metadata is recomputed from the bytes, so compare it with what the sender de
 
 - `GitManager`: TypeScript facade for the Rust engine lifecycle.
 - `GitManager.start()`: spawns the Rust binary through `smartrust` and starts the engine.
-- `GitManager.stop()`: shares one in-flight stop, cancels and cleans active archives, then confirms bridge process termination.
+- `GitManager.stop()`: shares one in-flight stop, cancels running remote transfers and active archives and waits for their cleanup, 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.
@@ -355,14 +422,18 @@ The metadata is recomputed from the bytes, so compare it with what the sender de
 - `GitManager.setSmartHttpRepositoryProtectedRefs()`: applies a complete revision-fenced set of exact protected-head rules and returns its effective revision and digest.
 - `GitManager.initBareRepository()`: creates an empty local bare repository.
 - `GitManager.importMirror()`: imports a remote repository with `git clone --mirror`. Supported remote forms are `https://`, `http://`, `ssh://`, `git://`, `file://`, and SCP-like `git@host:org/repo.git` URLs.
-- `GitManager.refreshMirror()`: atomically fetches and verifies the configured mirror source.
+- `GitManager.refreshMirror()`: atomically fetches and verifies the configured mirror source and mirrors its default branch.
 - `GitManager.importMirror()` and `GitManager.refreshMirror()` accept a `credential`, `caCertificates` and `timeoutMs`; see [Credentialed mirrors and repository size](#credentialed-mirrors-and-repository-size).
+- `GitManager.pushRefs()`: pushes leased ref updates to an `https` or loopback-IP `http` remote as one atomic transaction; see [Atomic pushes and the default branch](#atomic-pushes-and-the-default-branch).
+- `GitManager.importMirror(request, { signal? })`, `GitManager.refreshMirror(request, { signal? })` and `GitManager.pushRefs(request, { signal? })` run concurrently with other commands, hold mirror repositories against writes (`repositoryBusy`) and reject with `transferAborted` when aborted; see [Cancellation, concurrency and stop](#cancellation-concurrency-and-stop).
+- `GitManager.setDefaultBranch()`: points a repository's HEAD at an existing branch.
 - `GitManager.getRepositorySize()`: returns the exact object count, uncompressed object bytes and on-disk object storage bytes of a repository.
 - `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(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.openRepositoryService()`: opens a bounded upload-pack or protected receive-pack stream for an authenticated SSH-style ingress; a receive-pack carries a `guardTicketId`, which the facade chooses and releases itself when opening fails.
+- `GitManager.releaseRepositoryService(ticketId)`: releases a receive-pack's guard ticket; unknown or released tickets are a no-op.
 - `GitManager.listRepositories()`: lists local repositories managed below the configured data directory.
 - `GitManager.listRefs()`: lists one coherent page of the complete ref inventory of every namespace, with peeled tags, symbolic refs, HEAD, and a digest-bound cursor.
 - `GitManager.listTree()`: lists tree entries at a ref and optional path.
@@ -377,7 +448,7 @@ The metadata is recomputed from the bytes, so compare it with what the sender de
 - `GitManager.running`: local facade running state.
 - `RustGitManagerBridge`: lower-level typed bridge around `@push.rocks/smartrust`.
 - `GitManagerError` and `TGitManagerErrorCode`: typed failures with a stable `code`; `gitManagerArchivePathMetadataCeilingBytes` is the fixed archive path-metadata ceiling.
-- `IGitManagerAncestryRequest`, `IGitManagerArchiveInspectionRequest`, `IGitManagerArchiveInspectionOptions`, `IGitManagerArchiveInspection`, `IGitManagerOptions`, `IGitManagerStatus`, `IGitManagerReadinessOptions`, `TGitManagerReadinessResult`, `TGitManagerReadinessFailureReason`, `IRustGitManagerConfig`, `IGitManagerProtectedRefRule`, `IGitManagerSmartHttpRepositoryProtectedRefs`, `TGitManagerProtectedRefsApplyStatus`, and `IGitManagerProtectedRefsApplyResult`: exported option, status, readiness, and protected-ref contracts.
+- `IGitManagerAncestryRequest`, `IGitManagerArchiveInspectionRequest`, `IGitManagerArchiveInspectionOptions`, `IGitManagerArchiveInspection`, `IGitManagerOptions`, `IGitManagerStatus`, `IGitManagerReadinessOptions`, `TGitManagerReadinessResult`, `TGitManagerReadinessFailureReason`, `IRustGitManagerConfig`, `IGitManagerTransferControlOptions`, `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.
 
@@ -404,7 +475,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, 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`. `test/test.refinventory.node.ts` covers every ref namespace, peeled and nested tags, symbolic and dangling symbolic refs, unborn HEAD, prefix selection and exact lookup, ref names that are not valid UTF-8, pagination of 1,001 refs, stale and foreign cursors, 50,000 loose and packed refs, and a bundle round trip across namespaces. `test/test.pushlimits.node.ts` covers fixed-length and chunked Smart HTTP pushes over the limit, a complete pack followed by late excess bytes, an over-limit SSH-style receive-pack, an SSH-style receive-pack cut after Git already moved a ref (the update stays), and a bounded `stop()` while a service's output is never read, the rejected cases proving the refs unchanged, no Git or hook process left, no uncaught stream error, the engine serving, and a later push succeeding. `test/test.ancestry.node.ts` covers ancestors, the reverse direction, siblings, merges, unrelated histories, the same commit, invalid, missing and non-commit objects, a budget exceeded on a 20,000-commit history next to the exact answer, and a stalled walk whose Git process is killed. `test/test.archiveinspection.node.ts` runs every ci-spec archive conformance vector through `inspectArchive()` as bytes and as a chunked stream, the compressed limit at its boundary, an 8 MiB streamed archive, an early refusal that closes the source, and abort, source failure and `stop()` during an inspection.
+`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`. `test/test.refinventory.node.ts` covers every ref namespace, peeled and nested tags, symbolic and dangling symbolic refs, unborn HEAD, prefix selection and exact lookup, ref names that are not valid UTF-8, pagination of 1,001 refs, stale and foreign cursors, 50,000 loose and packed refs, and a bundle round trip across namespaces. `test/test.pushlimits.node.ts` covers fixed-length and chunked Smart HTTP pushes over the limit, a complete pack followed by late excess bytes, an over-limit SSH-style receive-pack, an SSH-style receive-pack cut after Git already moved a ref (the update stays), and a bounded `stop()` while a service's output is never read, the rejected cases proving the refs unchanged, no Git or hook process left, no uncaught stream error, the engine serving, and a later push succeeding. `test/test.ancestry.node.ts` covers ancestors, the reverse direction, siblings, merges, unrelated histories, the same commit, invalid, missing and non-commit objects, a budget exceeded on a 20,000-commit history next to the exact answer, and a stalled walk whose Git process is killed. `test/test.remotetransfer.node.ts` serves fixtures through `git http-backend` over HTTPS with a private CA and over plain HTTP on `127.0.0.1` and `[::1]`, and covers credentialed mirror imports and refreshes, the source default branch on import and refresh, `setDefaultBranch()`, the push URL policy, atomic creates, updates and deletes, stale leases that change no ref, a remote without the `atomic` capability, 5,000 creates and 5,000 deletes in one receive-pack request with no command line naming a ref, a stale lease on the last of 1,500 updates that changes no ref, and the credential staying out of every command line, error and file. Its fixture can hold or refuse a receive-pack request, which covers a ref that moves between the listing and the push (the remote fails all 1,500 updates) and a `413` answer (`remoteLimitExceeded`, no ref changed). It can also withhold pack requests to stall a transfer midway, which covers aborting an import (no repository or scratch left), a refresh (refs and HEAD unchanged) and a push, a push aborted before it sends its updates that changes nothing, other commands and transfers completing while transfers stall, `repositoryBusy` and the Smart HTTP `503` while a mirror refreshes, an atomic refresh that prunes nothing when one ref update fails, a refresh that times out inside its ref transaction without leaving lock files, a refresh refused during a Smart HTTP push, the receive-pack guard ticket (refused while held, admitted after release, idempotent release, released by `stop()`, released when its preparation times out on the bridge after the engine issued it), a bounded `stop()` during a stalled transfer, and a credentialed loopback `http` push that never reaches the `http_proxy`, `all_proxy` and `ALL_PROXY` set in the engine's environment. `test/test.archiveinspection.node.ts` runs every ci-spec archive conformance vector through `inspectArchive()` as bytes and as a chunked stream, the compressed limit at its boundary, an 8 MiB streamed archive, an early refusal that closes the source, and abort, source failure and `stop()` during an inspection.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

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