@foss.global/gitmanager 2.0.0 → 2.1.0

package/dist_ts/models.d.ts

@@ -67,6 +67,60 @@ export interface IGitManagerRepositoryArchive extends IGitManagerRepositorySelec
     extractedSizeBytes: number;
     entryCount: number;
 }
+/**
+ * Asks whether `ancestorObjectId` is reachable from `descendantObjectId`
+ * (`git merge-base --is-ancestor`; a commit is its own ancestor). Both must be
+ * full lowercase object IDs of commits in the repository; revision
+ * expressions, abbreviations, and tag objects are refused.
+ */
+export interface IGitManagerAncestryRequest extends IGitManagerRepositorySelector {
+    ancestorObjectId: string;
+    descendantObjectId: string;
+    /**
+     * Wall-clock work budget for the object lookup and the history walk,
+     * 1 to 60000 ms, default 10000. Exceeding it throws a `GitManagerError`
+     * with code `ancestryBudgetExceeded`.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Limits for inspecting one `tar.gz` archive. Every limit is inclusive.
+ */
+export interface IGitManagerArchiveInspectionRequest {
+    /** The archive bytes, or a stream of them; it is consumed and closed. */
+    archive: Uint8Array | AsyncIterable<Uint8Array>;
+    maxCompressedBytes: number;
+    maxExtractedBytes: number;
+    maxEntries: number;
+    /**
+     * Ceiling for the UTF-8 bytes of every effective entry path and symlink
+     * target, 1 to 134217728 (the fixed ci-spec ceiling, and the default).
+     */
+    maxPathMetadataBytes?: number;
+}
+export interface IGitManagerArchiveInspectionOptions {
+    signal?: AbortSignal;
+}
+/** Metadata recomputed from an accepted archive; nothing is taken on trust. */
+export interface IGitManagerArchiveInspection {
+    sizeBytes: number;
+    sha256: string;
+    extractedSizeBytes: number;
+    entryCount: number;
+    pathMetadataBytes: number;
+}
+/**
+ * Stable codes of `GitManagerError`.
+ *
+ * - `invalidObjectId`: an object ID is not a full lowercase SHA-1 or SHA-256.
+ * - `objectNotFound`: the object does not exist in the repository.
+ * - `objectNotCommit`: the object exists but is not a commit.
+ * - `ancestryBudgetExceeded`: the ancestry check exceeded `timeoutMs`; the
+ *   answer is unknown, never `false`.
+ * - `archiveLimitExceeded`: the archive exceeds a requested limit.
+ * - `archiveRejected`: the archive breaks a format, path, or link rule.
+ */
+export type TGitManagerErrorCode = 'invalidObjectId' | 'objectNotFound' | 'objectNotCommit' | 'ancestryBudgetExceeded' | 'archiveLimitExceeded' | 'archiveRejected';
 export interface IGitManagerRepositoryLfsPointer {
     oid: string;
     sizeBytes: number;

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

@@ -1,9 +1,12 @@
 import * as plugins from './plugins.js';
-import type { 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, IRustGitManagerConfig, TGitManagerRefInventoryResult, IRustGitManagerRepositoryServiceDescriptor } from './models.js';
+import type { IGitManagerAncestryRequest, 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, IRustGitManagerConfig, TGitManagerRefInventoryResult, IRustGitManagerRepositoryServiceDescriptor } from './models.js';
 export declare class RustGitManagerBridge extends plugins.EventEmitter {
     private bridge;
+    private binaryLocator;
     constructor();
     spawn(): Promise<boolean>;
+    /** Resolves the engine binary the bridge spawns, for its one-shot modes. */
+    findBinary(): Promise<string>;
     kill(): void;
     terminate(): Promise<void>;
     get running(): boolean;
@@ -27,6 +30,7 @@ export declare class RustGitManagerBridge extends plugins.EventEmitter {
     mergeRepository(requestArg: IGitManagerMergeRequest): Promise<IGitManagerMergeResult>;
     listTree(requestArg: IGitManagerTreeRequest): Promise<IGitManagerTreeEntry[]>;
     readFile(requestArg: IGitManagerReadFileRequest): Promise<IGitManagerFileContent>;
+    isAncestor(requestArg: IGitManagerAncestryRequest): Promise<boolean>;
     listCommits(requestArg: IGitManagerListCommitsRequest): Promise<IGitManagerCommitSummary[]>;
     getCommit(requestArg: IGitManagerCommitRequest): Promise<IGitManagerCommitDetail>;
     getDiff(requestArg: IGitManagerDiffRequest): Promise<IGitManagerDiff>;

package/dist_ts/rust-gitmanager-bridge.js

@@ -1,4 +1,5 @@
 import * as plugins from './plugins.js';
+import { GitManagerError, isGitManagerErrorCode } from './classes.gitmanagererror.js';
 function getPackageRoot() {
     const thisDir = plugins.path.dirname(plugins.url.fileURLToPath(import.meta.url));
     return plugins.path.resolve(thisDir, '..');
@@ -22,14 +23,31 @@ function buildLocalPaths() {
     paths.push(plugins.path.resolve(process.cwd(), 'rust', 'target', 'debug', 'rustgitmanager'));
     return paths;
 }
+/**
+ * Rethrows a Rust response that carries a stable GitManager error code as a
+ * `GitManagerError`; every other failure is rethrown unchanged.
+ */
+const rethrowCodedError = (errorArg) => {
+    if (errorArg instanceof plugins.smartrust.RustBridgeRequestError
+        && isGitManagerErrorCode(errorArg.responseErrorCode)) {
+        throw new GitManagerError(errorArg.responseErrorCode, errorArg.message, {
+            cause: errorArg,
+        });
+    }
+    throw errorArg;
+};
 export class RustGitManagerBridge extends plugins.EventEmitter {
     constructor() {
         super();
-        this.bridge = new plugins.smartrust.RustBridge({
+        const binaryLocatorOptions = {
             binaryName: 'rustgitmanager',
             envVarName: 'GITMANAGER_RUST_BINARY',
             platformPackagePrefix: '@foss.global/gitmanager',
             localPaths: buildLocalPaths(),
+        };
+        this.binaryLocator = new plugins.smartrust.RustBinaryLocator(binaryLocatorOptions);
+        this.bridge = new plugins.smartrust.RustBridge({
+            ...binaryLocatorOptions,
             requestTimeoutMs: 130000,
             readyTimeoutMs: 10000,
         });
@@ -43,6 +61,14 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     async spawn() {
         return this.bridge.spawn();
     }
+    /** Resolves the engine binary the bridge spawns, for its one-shot modes. */
+    async findBinary() {
+        const binaryPath = await this.binaryLocator.findBinary();
+        if (!binaryPath) {
+            throw new Error('Unable to locate the rustgitmanager binary');
+        }
+        return binaryPath;
+    }
     kill() {
         this.bridge.kill();
     }
@@ -164,6 +190,19 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     async readFile(requestArg) {
         return this.bridge.sendCommand('readFile', requestArg);
     }
+    async isAncestor(requestArg) {
+        const result = await this.bridge.sendCommand('isAncestor', {
+            org: requestArg.org,
+            repo: requestArg.repo,
+            ancestorObjectId: requestArg.ancestorObjectId,
+            descendantObjectId: requestArg.descendantObjectId,
+            ...(requestArg.timeoutMs === undefined ? {} : { timeoutMs: requestArg.timeoutMs }),
+        }).catch(rethrowCodedError);
+        if (typeof result !== 'boolean') {
+            throw new Error('Rust GitManager returned an invalid ancestry result');
+        }
+        return result;
+    }
     async listCommits(requestArg) {
         return this.bridge.sendCommand('listCommits', requestArg);
     }
@@ -180,4 +219,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":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAqFtF,SAAS,cAAc;IACrB,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACjF,OAAO,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC;AAED,SAAS,uBAAuB;IAC9B,MAAM,OAAO,GAA2B,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACzE,MAAM,KAAK,GAA2B,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC1E,MAAM,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,OAAO,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7C,CAAC;AAED,SAAS,eAAe;IACtB,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IACrC,MAAM,MAAM,GAAG,uBAAuB,EAAE,CAAC;IACzC,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,IAAI,MAAM,EAAE,CAAC;QACX,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,kBAAkB,MAAM,EAAE,CAAC,CAAC,CAAC;IACtF,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC1E,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC/F,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAE7F,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,iBAAiB,GAAG,CAAC,QAAiB,EAAS,EAAE;IACrD,IACE,QAAQ,YAAY,OAAO,CAAC,SAAS,CAAC,sBAAsB;WACzD,qBAAqB,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EACpD,CAAC;QACD,MAAM,IAAI,eAAe,CAAC,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,CAAC,OAAO,EAAE;YACtE,KAAK,EAAE,QAAQ;SAChB,CAAC,CAAC;IACL,CAAC;IACD,MAAM,QAAQ,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,OAAO,oBAAqB,SAAQ,OAAO,CAAC,YAAY;IAI5D;QACE,KAAK,EAAE,CAAC;QACR,MAAM,oBAAoB,GAA4C;YACpE,UAAU,EAAE,gBAAgB;YAC5B,UAAU,EAAE,wBAAwB;YACpC,qBAAqB,EAAE,yBAAyB;YAChD,UAAU,EAAE,eAAe,EAAE;SAC9B,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;QACnF,IAAI,CAAC,MAAM,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,UAAU,CAAsB;YAClE,GAAG,oBAAoB;YACvB,gBAAgB,EAAE,MAAM;YACxB,cAAc,EAAE,KAAK;SACtB,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAmB,EAAE,MAAqB,EAAE,EAAE;YACpE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAY,EAAE,EAAE;YACxC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC7B,CAAC;IAED,4EAA4E;IACrE,KAAK,CAAC,UAAU;QACrB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;QACzD,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAEM,IAAI;QACT,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAEM,KAAK,CAAC,SAAS;QACpB,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;IAChC,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IAC7B,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,SAAgC;QAC3D,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAChE,CAAC;IAEM,KAAK,CAAC,cAAc;QACzB,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEM,KAAK,CAAC,SAAS,CACpB,UAAwD;QAExD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC;IAC9D,CAAC;IAEM,KAAK,CAAC,4BAA4B,CAAC,SAA+C;QACvF,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,8BAA8B,EAAE,SAAS,CAAC,CAAC;IAC3E,CAAC;IAEM,KAAK,CAAC,gCAAgC,CAC3C,aAAuD;QAEvD,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,kCAAkC,EAAE,aAAa,CAAC,CAAC;IACnF,CAAC;IAEM,KAAK,CAAC,mCAAmC,CAC9C,gBAA6D;QAE7D,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAC5B,qCAAqC,EACrC,gBAAgB,CACjB,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAAC,UAAgD;QAC9E,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,UAA0C;QAClE,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;IAC7D,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,UAAyC;QAClE,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;IAC9D,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAAC,UAAyC;QACrE,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC;IACjE,CAAC;IAEM,KAAK,CAAC,sBAAsB,CACjC,UAAyC;QAEzC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,wBAAwB,EAAE,UAAU,CAAC,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,uBAAuB,CAClC,UAA+C,EAC/C,aAAkD,EAAE;QAEpD,IAAI,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;YAC/B,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC1F,CAAC;QACD,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAChD,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,yBAAyB,EAAE;YACxE,WAAW;YACX,OAAO,EAAE,UAAU;SACpB,EAAE;YACD,SAAS,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI;SAC1B,CAAC,CAAC;QACH,IAAI,aAES,CAAC;QACd,MAAM,aAAa,GAAG,GAAS,EAAE;YAC/B,aAAa,KAAK,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,yBAAyB,EAAE;gBACnE,WAAW;aACZ,EAAE;gBACD,SAAS,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI;aAC1B,CAAC,CAAC;QACL,CAAC,CAAC;QACF,UAAU,CAAC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5E,IAAI,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;YAC/B,aAAa,EAAE,CAAC;QAClB,CAAC;QAED,IAAI,MAAoC,CAAC;QACzC,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,cAAc,CAAC;YAC9B,IAAI,aAAa,EAAE,CAAC;gBAClB,MAAM,aAAa,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC;QAAC,OAAO,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,MAAM,YAAY,CAAC;YACrB,CAAC;YACD,MAAM,YAAY,GAAG,MAAM,aAAa,CAAC;YACzC,IAAI,YAAY,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;gBACxC,MAAM,UAAU,CAAC,MAAM,EAAE,MAAM;uBAC1B,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;YAC7D,CAAC;YACD,MAAM,YAAY,CAAC;QACrB,CAAC;gBAAS,CAAC;YACT,UAAU,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QACjE,CAAC;QACD,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI;YAC3B,CAAC,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC;YAC/B,CAAC,oBAAoB,EAAE,MAAM,CAAC,kBAAkB,CAAC;YACjD,CAAC,YAAY,EAAE,MAAM,CAAC,UAAU,CAAC;SACzB,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBAC9C,MAAM,IAAI,KAAK,CAAC,uCAAuC,KAAK,EAAE,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,KAAK,CAAC,wBAAwB,CACnC,UAA+C;QAE/C,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,0BAA0B,EAAE,UAAU,CAAC,CAAC;IACzE,CAAC;IAEM,KAAK,CAAC,uBAAuB,CAClC,UAA2C;QAE3C,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,yBAAyB,EAAE,UAAU,CAAC,CAAC;IACxE,CAAC;IAEM,KAAK,CAAC,gBAAgB;QAC3B,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,QAAQ,CACnB,UAAiC;QAEjC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,yBAAyB,CACpC,UAAyC;QAEzC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,2BAA2B,EAAE,UAAU,CAAC,CAAC;IAC1E,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,UAAmC;QAEnC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;IAChE,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,UAAkC;QACtD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,UAAsC;QAC1D,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,UAAsC;QAC5D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE;YACzD,GAAG,EAAE,UAAU,CAAC,GAAG;YACnB,IAAI,EAAE,UAAU,CAAC,IAAI;YACrB,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;YAC7C,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;YACjD,GAAG,CAAC,UAAU,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,SAAS,EAAE,CAAC;SACnF,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAC5B,IAAI,OAAO,MAAM,KAAK,SAAS,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,UAAyC;QAChE,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IAC5D,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,UAAoC;QACzD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IAC1D,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,UAAkC;QACrD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IACxD,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,UAAsC;QAC1D,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,UAAiC;QACnD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IACvD,CAAC;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foss.global/gitmanager",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "private": false,
   "description": "Headless Git manager for the foss.global Git platform, with a TypeScript API and Rust engine.",
   "exports": {
@@ -14,13 +14,13 @@
     "@push.rocks/smartrust": "^1.7.0"
   },
   "devDependencies": {
-    "@foss.global/ci-spec": "0.2.0",
+    "@foss.global/ci-spec": "1.1.1",
     "@git.zone/tsbuild": "^5.0.0",
     "@git.zone/tsdoc": "^2.2.2",
-    "@git.zone/tsrun": "^3.0.0",
-    "@git.zone/tsrust": "^1.15.0",
-    "@git.zone/tstest": "^6.2.0",
-    "@types/node": "^26.6.1"
+    "@git.zone/tsrun": "^3.0.1",
+    "@git.zone/tsrust": "^1.15.1",
+    "@git.zone/tstest": "^6.3.2",
+    "@types/node": "^26.6.2"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -283,6 +283,39 @@ 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`.
 
+## Commit ancestry
+
+`isAncestor()` answers `git merge-base --is-ancestor` exactly: whether the ancestor commit is reachable from the descendant commit, where a commit is its own ancestor. Both object IDs must be full lowercase SHA-1 or SHA-256 IDs of commits in the repository; revision expressions, abbreviations, and tag objects are refused, so peel a tag before asking.
+
+```ts
+// Throws GitManagerError (error.code) unless the answer is exact.
+const reachableFromMain = await gitManager.isAncestor({
+  org: 'foss.global',
+  repo: 'gitmanager',
+  ancestorObjectId: taggedCommitId,
+  descendantObjectId: mainTipCommitId,
+  timeoutMs: 10_000,
+});
+```
+
+`timeoutMs` is the work budget for the object lookup and the history walk together: 1 to 60000 ms, 10000 by default. When it runs out, the Git process is killed and the call throws. It never returns `false` for anything but an exact answer; the typed codes are `invalidObjectId`, `objectNotFound`, `objectNotCommit`, and `ancestryBudgetExceeded`. The check runs on the serial management channel like the other read APIs.
+
+## Archive inspection
+
+`inspectArchive()` validates a `tar.gz` on the receiving side of a transfer, for example a CI artifact or cache upload. It streams the archive, given as a `Uint8Array` or any async iterable of `Uint8Array` chunks such as a Node stream or a fetch body, into a dedicated engine process. That process checks every entry against the rules GitManager applies to its own source archives and the `@foss.global/ci-spec` archive conformance vectors: safe relative paths, no duplicates or late ancestors, only regular files, directories and symlinks whose targets stay inside the root (including through chains), USTAR and supported PAX metadata only, zeroed padding, no trailing data or concatenated gzip members, and the fixed 134,217,728-byte path-metadata ceiling.
+
+```ts
+const inspection = await gitManager.inspectArchive({
+  archive: uploadStream,
+  maxCompressedBytes: 16 * 1024 ** 3,
+  maxExtractedBytes: 128 * 1024 ** 3,
+  maxEntries: 1_000_000,
+}, { signal });
+// { sizeBytes, sha256, extractedSizeBytes, entryCount, pathMetadataBytes }
+```
+
+The metadata is recomputed from the bytes, so compare it with what the sender declared rather than trusting the declaration. Every limit is inclusive and must be a non-negative safe integer; `maxPathMetadataBytes` is 1 to 134217728 and defaults to the ceiling. A refused archive throws a `GitManagerError` with code `archiveLimitExceeded` (a requested limit) or `archiveRejected` (a format, path, or link rule), and the inspector stops reading at the first violation and closes the source. Aborting the signal or calling `stop()` kills the inspector; the call rejects only after the process exited. The inspection does not use the management channel, so several can run at once.
+
 ## Public API
 
 - `GitManager`: TypeScript facade for the Rust engine lifecycle.
@@ -310,9 +343,12 @@ When Git Smart HTTP is running on a loopback bind, the probe targets the engine'
 - `GitManager.getDiff()`: returns a structured unified diff between a head ref and its first parent or an explicit base ref.
 - `GitManager.listTags()`: lists lightweight and annotated tags with target object metadata.
 - `GitManager.getTag()`: reads one tag by exact name.
+- `GitManager.isAncestor()`: answers exact commit ancestry within a work budget, with typed errors for anything else.
+- `GitManager.inspectArchive(request, { signal? })`: streams a receiver-side `tar.gz` through the engine inspector and returns its recomputed metadata or a typed refusal.
 - `GitManager.running`: local facade running state.
 - `RustGitManagerBridge`: lower-level typed bridge around `@push.rocks/smartrust`.
-- `IGitManagerOptions`, `IGitManagerStatus`, `IGitManagerReadinessOptions`, `TGitManagerReadinessResult`, `TGitManagerReadinessFailureReason`, `IRustGitManagerConfig`, `IGitManagerProtectedRefRule`, `IGitManagerSmartHttpRepositoryProtectedRefs`, `TGitManagerProtectedRefsApplyStatus`, and `IGitManagerProtectedRefsApplyResult`: exported option, status, readiness, and protected-ref contracts.
+- `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.
 
 Repository/read DTO contracts are re-exported from the published `@foss.global/interfaces` package.
 
@@ -339,7 +375,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.
+`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.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

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

package/ts/classes.archiveinspection.ts

@@ -0,0 +1,245 @@
+import * as plugins from './plugins.js';
+import { GitManagerError } from './classes.gitmanagererror.js';
+import type {
+  IGitManagerArchiveInspection,
+  IGitManagerArchiveInspectionRequest,
+} from './models.js';
+
+/** The fixed ci-spec path-metadata ceiling of every archive. */
+export const gitManagerArchivePathMetadataCeilingBytes = 134_217_728;
+
+const maxInspectorOutputBytes = 64 * 1024;
+
+type TInspectorSettlement =
+  | { kind: 'closed'; code: number | null; signal: NodeJS.Signals | null }
+  | { kind: 'spawnFailed'; error: Error };
+
+const assertLimit = (
+  nameArg: string,
+  valueArg: number,
+  minimumArg: number,
+  maximumArg: number,
+): void => {
+  if (!Number.isSafeInteger(valueArg) || valueArg < minimumArg || valueArg > maximumArg) {
+    throw new TypeError(
+      `${nameArg} must be a safe integer between ${minimumArg} and ${maximumArg}.`,
+    );
+  }
+};
+
+const isRecord = (valueArg: unknown): valueArg is Record<string, unknown> =>
+  typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+
+const isCount = (valueArg: unknown): valueArg is number =>
+  typeof valueArg === 'number' && Number.isSafeInteger(valueArg) && valueArg >= 0;
+
+/**
+ * Parses the inspector's single JSON result: the recomputed metadata of an
+ * accepted archive, or a thrown `GitManagerError` for a refused one.
+ */
+const parseInspectorResult = (stdoutArg: string): IGitManagerArchiveInspection => {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(stdoutArg);
+  } catch (error) {
+    throw new Error('Archive inspector returned invalid JSON', { cause: error });
+  }
+  if (isRecord(parsed) && parsed.status === 'rejected' && typeof parsed.message === 'string') {
+    if (parsed.reason === 'limitExceeded') {
+      throw new GitManagerError('archiveLimitExceeded', parsed.message);
+    }
+    if (parsed.reason === 'invalid') {
+      throw new GitManagerError('archiveRejected', parsed.message);
+    }
+  }
+  if (
+    isRecord(parsed)
+    && parsed.status === 'accepted'
+    && isCount(parsed.sizeBytes)
+    && typeof parsed.sha256 === 'string'
+    && /^[0-9a-f]{64}$/.test(parsed.sha256)
+    && isCount(parsed.extractedSizeBytes)
+    && isCount(parsed.entryCount)
+    && isCount(parsed.pathMetadataBytes)
+  ) {
+    return {
+      sizeBytes: parsed.sizeBytes,
+      sha256: parsed.sha256,
+      extractedSizeBytes: parsed.extractedSizeBytes,
+      entryCount: parsed.entryCount,
+      pathMetadataBytes: parsed.pathMetadataBytes,
+    };
+  }
+  throw new Error('Archive inspector returned an invalid result');
+};
+
+/**
+ * Streams one archive into a dedicated engine inspector process and returns
+ * its recomputed metadata. The inspector reads until the archive is accepted
+ * or the first violation; on a refusal the remaining input is not read and
+ * the source is closed. Aborting `signalArg` kills the inspector and rejects
+ * with the abort reason once the process has exited.
+ */
+export const runArchiveInspection = async (
+  binaryPathArg: string,
+  requestArg: IGitManagerArchiveInspectionRequest,
+  signalArg: AbortSignal,
+): Promise<IGitManagerArchiveInspection> => {
+  const maxPathMetadataBytes =
+    requestArg.maxPathMetadataBytes ?? gitManagerArchivePathMetadataCeilingBytes;
+  assertLimit('maxCompressedBytes', requestArg.maxCompressedBytes, 0, Number.MAX_SAFE_INTEGER);
+  assertLimit('maxExtractedBytes', requestArg.maxExtractedBytes, 0, Number.MAX_SAFE_INTEGER);
+  assertLimit('maxEntries', requestArg.maxEntries, 0, Number.MAX_SAFE_INTEGER);
+  assertLimit(
+    'maxPathMetadataBytes',
+    maxPathMetadataBytes,
+    1,
+    gitManagerArchivePathMetadataCeilingBytes,
+  );
+  if (signalArg.aborted) {
+    throw signalArg.reason;
+  }
+
+  const child = plugins.childProcess.spawn(binaryPathArg, [
+    '--inspect-archive-stream',
+    '--max-compressed-bytes',
+    String(requestArg.maxCompressedBytes),
+    '--max-extracted-bytes',
+    String(requestArg.maxExtractedBytes),
+    '--max-entries',
+    String(requestArg.maxEntries),
+    '--max-path-metadata-bytes',
+    String(maxPathMetadataBytes),
+  ], { stdio: ['pipe', 'pipe', 'pipe'] });
+  const killInspector = (): void => {
+    if (child.exitCode === null && child.signalCode === null) {
+      child.kill('SIGKILL');
+    }
+  };
+
+  const settled = new Promise<TInspectorSettlement>((resolve) => {
+    child.once('error', (error) => {
+      killInspector();
+      resolve({ kind: 'spawnFailed', error });
+    });
+    child.once('close', (code, signal) => resolve({ kind: 'closed', code, signal }));
+  });
+  let inspectorSettled = false;
+  void settled.then(() => {
+    inspectorSettled = true;
+  });
+
+  const stdoutChunks: Buffer[] = [];
+  const stderrChunks: Buffer[] = [];
+  let outputBytes = 0;
+  let outputOverflow = false;
+  const collect = (chunksArg: Buffer[]) => (chunkArg: Buffer): void => {
+    outputBytes += chunkArg.byteLength;
+    if (outputBytes > maxInspectorOutputBytes) {
+      outputOverflow = true;
+      killInspector();
+      return;
+    }
+    chunksArg.push(chunkArg);
+  };
+  child.stdout.on('data', collect(stdoutChunks));
+  child.stderr.on('data', collect(stderrChunks));
+
+  // A write error is the inspector closing its input after a refusal (or
+  // dying); its exit status and result decide the outcome.
+  child.stdin.on('error', () => undefined);
+
+  let aborted = false;
+  const abortInspection = (): void => {
+    aborted = true;
+    killInspector();
+  };
+  signalArg.addEventListener('abort', abortInspection, { once: true });
+
+  let delivered = false;
+  let sourceFailure: { error: unknown } | undefined;
+  const waitForDrain = (): Promise<unknown> => Promise.race([
+    new Promise<void>((resolve) => {
+      const done = (): void => {
+        child.stdin.off('drain', done);
+        child.stdin.off('close', done);
+        resolve();
+      };
+      child.stdin.once('drain', done);
+      child.stdin.once('close', done);
+    }),
+    settled,
+  ]);
+  const feed = async (): Promise<void> => {
+    const archive = requestArg.archive;
+    if (archive instanceof Uint8Array) {
+      child.stdin.end(archive);
+      delivered = true;
+      return;
+    }
+    const iterator = archive[Symbol.asyncIterator]();
+    let exhausted = false;
+    try {
+      while (!inspectorSettled) {
+        const step = await Promise.race([
+          iterator.next().then((result) => ({ kind: 'chunk' as const, result })),
+          settled.then(() => ({ kind: 'settled' as const })),
+        ]);
+        if (step.kind === 'settled' || inspectorSettled) {
+          return;
+        }
+        if (step.result.done) {
+          exhausted = true;
+          child.stdin.end();
+          delivered = true;
+          return;
+        }
+        if (!(step.result.value instanceof Uint8Array)) {
+          throw new TypeError('The archive stream must yield Uint8Array chunks.');
+        }
+        if (!child.stdin.write(step.result.value)) {
+          await waitForDrain();
+        }
+      }
+    } catch (error) {
+      sourceFailure = { error };
+      killInspector();
+    } finally {
+      if (!exhausted && !sourceFailure) {
+        // Close the source like a `for await` loop that stops early; a
+        // stalled source must not hold the inspection open.
+        void Promise.resolve(iterator.return?.()).catch(() => undefined);
+      }
+    }
+  };
+
+  try {
+    const [settlement] = await Promise.all([settled, feed()]);
+    if (aborted) {
+      throw signalArg.reason;
+    }
+    if (sourceFailure) {
+      throw sourceFailure.error;
+    }
+    if (settlement.kind === 'spawnFailed') {
+      throw new Error('Failed to spawn the archive inspector', { cause: settlement.error });
+    }
+    if (outputOverflow) {
+      throw new Error('Archive inspector output exceeded its limit');
+    }
+    if (settlement.code !== 0) {
+      const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+      throw new Error(
+        `Archive inspector failed with ${settlement.signal ?? `status ${settlement.code}`}`
+          + (stderr ? `: ${stderr}` : ''),
+      );
+    }
+    const inspection = parseInspectorResult(Buffer.concat(stdoutChunks).toString('utf8'));
+    if (!delivered) {
+      throw new Error('Archive inspector accepted an archive that was not completely delivered');
+    }
+    return inspection;
+  } finally {
+    signalArg.removeEventListener('abort', abortInspection);
+  }
+};

package/ts/classes.gitmanager.ts

@@ -1,5 +1,9 @@
 import * as plugins from './plugins.js';
 import type {
+  IGitManagerAncestryRequest,
+  IGitManagerArchiveInspection,
+  IGitManagerArchiveInspectionOptions,
+  IGitManagerArchiveInspectionRequest,
   IGitManagerCommitDetail,
   IGitManagerCommitRequest,
   IGitManagerCommitSummary,
@@ -41,6 +45,7 @@ import type {
 } from './models.js';
 import { RustGitManagerBridge } from './rust-gitmanager-bridge.js';
 import { GitManagerRepositoryService } from './classes.repositoryservice.js';
+import { runArchiveInspection } from './classes.archiveinspection.js';
 
 const readinessDefaultTimeoutMs = 2_000;
 const readinessMaximumTimeoutMs = 30_000;
@@ -56,6 +61,7 @@ export class GitManager extends plugins.EventEmitter {
   private stopPromise: Promise<void> | null = null;
   private config: IRustGitManagerConfig;
   private readonly repositoryServices = new Set<GitManagerRepositoryService>();
+  private readonly archiveInspections = new Map<AbortController, Promise<unknown>>();
   private lifecycleEpoch = 0;
   private smartHttpProbeUrl: string | null = null;
   private readonly activeReadinessControllers = new Set<AbortController>();
@@ -168,12 +174,14 @@ export class GitManager extends plugins.EventEmitter {
     }
     if (!this.bridge.running) {
       await this.closeRepositoryServices();
+      await this.abortArchiveInspections();
       await this.bridge.terminate();
       this.started = false;
       return;
     }
     try {
       await this.closeRepositoryServices();
+      await this.abortArchiveInspections();
       await this.bridge.stopGitManager();
     } finally {
       await this.bridge.terminate();
@@ -440,6 +448,51 @@ export class GitManager extends plugins.EventEmitter {
     return this.bridge.readFile(requestArg);
   }
 
+  /**
+   * Answers `git merge-base --is-ancestor` exactly within a work budget.
+   * Anything short of an exact answer throws a `GitManagerError`
+   * (`invalidObjectId`, `objectNotFound`, `objectNotCommit`,
+   * `ancestryBudgetExceeded`); it never degrades to `false`.
+   */
+  public async isAncestor(requestArg: IGitManagerAncestryRequest): Promise<boolean> {
+    this.assertRunning();
+    return this.bridge.isAncestor(requestArg);
+  }
+
+  /**
+   * Inspects a receiver-side `tar.gz` archive in a dedicated engine process:
+   * recomputes its compressed size, SHA-256, extracted bytes, entry count,
+   * and path metadata bytes while enforcing the limits and the ci-spec path
+   * and link rules. A refused archive throws a `GitManagerError` with code
+   * `archiveLimitExceeded` or `archiveRejected`; an invalid limit throws a
+   * `TypeError`. `stop()` aborts inspections in flight.
+   */
+  public async inspectArchive(
+    requestArg: IGitManagerArchiveInspectionRequest,
+    optionsArg: IGitManagerArchiveInspectionOptions = {},
+  ): Promise<IGitManagerArchiveInspection> {
+    this.assertRunning();
+    const controller = new AbortController();
+    const callerSignal = optionsArg.signal;
+    const abortForCaller = (): void => {
+      controller.abort(callerSignal?.reason);
+    };
+    if (callerSignal?.aborted) {
+      throw callerSignal.reason;
+    }
+    callerSignal?.addEventListener('abort', abortForCaller, { once: true });
+    const inspection = this.bridge.findBinary().then((binaryPath) => {
+      return runArchiveInspection(binaryPath, requestArg, controller.signal);
+    });
+    this.archiveInspections.set(controller, inspection);
+    try {
+      return await inspection;
+    } finally {
+      callerSignal?.removeEventListener('abort', abortForCaller);
+      this.archiveInspections.delete(controller);
+    }
+  }
+
   public async listCommits(requestArg: IGitManagerListCommitsRequest): Promise<IGitManagerCommitSummary[]> {
     this.assertRunning();
     return this.bridge.listCommits(requestArg);
@@ -675,6 +728,15 @@ export class GitManager extends plugins.EventEmitter {
     }
   }
 
+  private async abortArchiveInspections(): Promise<void> {
+    const inspections = [...this.archiveInspections];
+    this.archiveInspections.clear();
+    for (const [controller] of inspections) {
+      controller.abort(new Error('GitManager stopped during archive inspection'));
+    }
+    await Promise.all(inspections.map(([, inspection]) => inspection.catch(() => undefined)));
+  }
+
   private async closeRepositoryServices(): Promise<void> {
     const services = [...this.repositoryServices];
     this.repositoryServices.clear();