@pipeline-builder/api-core 4.1.21 → 5.0.0

package/lib/errors/app-errors.d.ts

@@ -25,7 +25,9 @@ export declare class ValidationError extends AppError {
     constructor(message: string);
 }
 /** 409 — Conflict / duplicate. `code` narrows the conflict for clients
- *  (e.g. `PLUGIN_VERSION_FROZEN`); it must be a 409-mapped code. */
+ *  (e.g. `PLUGIN_VERSION_FROZEN`); it must be a 409-mapped code. `details`
+ *  carries what the client needs to resolve it — for a taken pipeline slot,
+ *  the NORMALIZED names that collided and the id to PUT instead. */
 export declare class ConflictError extends AppError {
-    constructor(message: string, code?: ErrorCode);
+    constructor(message: string, code?: ErrorCode, details?: Record<string, unknown>);
 }

package/lib/errors/app-errors.js

@@ -41,11 +41,13 @@ export class ValidationError extends AppError {
     }
 }
 /** 409 — Conflict / duplicate. `code` narrows the conflict for clients
- *  (e.g. `PLUGIN_VERSION_FROZEN`); it must be a 409-mapped code. */
+ *  (e.g. `PLUGIN_VERSION_FROZEN`); it must be a 409-mapped code. `details`
+ *  carries what the client needs to resolve it — for a taken pipeline slot,
+ *  the NORMALIZED names that collided and the id to PUT instead. */
 export class ConflictError extends AppError {
-    constructor(message, code = ErrorCode.CONFLICT) {
-        super(getStatusForErrorCode(ErrorCode.CONFLICT), code, message);
+    constructor(message, code = ErrorCode.CONFLICT, details) {
+        super(getStatusForErrorCode(ErrorCode.CONFLICT), code, message, details);
         this.name = 'ConflictError';
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWVycm9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lcnJvcnMvYXBwLWVycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLE9BQU8sRUFBRSxTQUFTLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUUzRTs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sUUFBUyxTQUFRLEtBQUs7SUFFZixVQUFVO0lBQ1YsSUFBSTtJQUdKLE9BQU87SUFMekIsWUFDa0IsVUFBa0IsRUFDbEIsSUFBZSxFQUMvQixPQUFlO0lBQ2YsZ0ZBQWdGO0lBQ2hFLE9BQWlDO1FBRWpELEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQzswQkFOQyxVQUFVO29CQUNWLElBQUk7dUJBR0osT0FBTztRQUd2QixJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQztJQUN6QixDQUFDO0NBQ0Y7QUFFRCxnQ0FBZ0M7QUFDaEMsTUFBTSxPQUFPLGFBQWMsU0FBUSxRQUFRO0lBQ3pDLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMscUJBQXFCLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxTQUFTLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDaEYsSUFBSSxDQUFDLElBQUksR0FBRyxlQUFlLENBQUM7SUFDOUIsQ0FBQztDQUNGO0FBRUQsc0NBQXNDO0FBQ3RDLE1BQU0sT0FBTyxjQUFlLFNBQVEsUUFBUTtJQUMxQyxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLHFCQUFxQixDQUFDLFNBQVMsQ0FBQyx3QkFBd0IsQ0FBQyxFQUFFLFNBQVMsQ0FBQyx3QkFBd0IsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUM5RyxJQUFJLENBQUMsSUFBSSxHQUFHLGdCQUFnQixDQUFDO0lBQy9CLENBQUM7Q0FDRjtBQUVELHNDQUFzQztBQUN0QyxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxRQUFRO0lBQzNDLFlBQVksT0FBZTtRQUN6QixLQUFLLENBQUMscUJBQXFCLENBQUMsU0FBUyxDQUFDLGdCQUFnQixDQUFDLEVBQUUsU0FBUyxDQUFDLGdCQUFnQixFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzlGLElBQUksQ0FBQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7SUFDaEMsQ0FBQztDQUNGO0FBRUQ7b0VBQ29FO0FBQ3BFLE1BQU0sT0FBTyxhQUFjLFNBQVEsUUFBUTtJQUN6QyxZQUFZLE9BQWUsRUFBRSxJQUFJLEdBQWMsU0FBUyxDQUFDLFFBQVE7UUFDL0QsS0FBSyxDQUFDLHFCQUFxQixDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDaEUsSUFBSSxDQUFDLElBQUksR0FBRyxlQUFlLENBQUM7SUFDOUIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmltcG9ydCB7IEVycm9yQ29kZSwgZ2V0U3RhdHVzRm9yRXJyb3JDb2RlIH0gZnJvbSAnLi4vdHlwZXMvZXJyb3ItY29kZXMuanMnO1xuXG4vKipcbiAqIEJhc2UgYXBwbGljYXRpb24gZXJyb3Igd2l0aCBIVFRQIHN0YXR1cyBjb2RlIGFuZCBlcnJvciBjb2RlLlxuICogRXh0ZW5kIHRoaXMgZm9yIGRvbWFpbi1zcGVjaWZpYyBlcnJvciB0eXBlcy5cbiAqL1xuZXhwb3J0IGNsYXNzIEFwcEVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgcmVhZG9ubHkgc3RhdHVzQ29kZTogbnVtYmVyLFxuICAgIHB1YmxpYyByZWFkb25seSBjb2RlOiBFcnJvckNvZGUsXG4gICAgbWVzc2FnZTogc3RyaW5nLFxuICAgIC8qKiBTdHJ1Y3R1cmVkIGNvbnRleHQgc2VudCB3aXRoIHRoZSBlcnJvciByZXNwb25zZSAoZS5nLiB0aGUgZmFpbGluZyBnYXRlcykuICovXG4gICAgcHVibGljIHJlYWRvbmx5IGRldGFpbHM/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPixcbiAgKSB7XG4gICAgc3VwZXIobWVzc2FnZSk7XG4gICAgdGhpcy5uYW1lID0gJ0FwcEVycm9yJztcbiAgfVxufVxuXG4vKiogNDA0IOKAlCBSZXNvdXJjZSBub3QgZm91bmQuICovXG5leHBvcnQgY2xhc3MgTm90Rm91bmRFcnJvciBleHRlbmRzIEFwcEVycm9yIHtcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nKSB7XG4gICAgc3VwZXIoZ2V0U3RhdHVzRm9yRXJyb3JDb2RlKEVycm9yQ29kZS5OT1RfRk9VTkQpLCBFcnJvckNvZGUuTk9UX0ZPVU5ELCBtZXNzYWdlKTtcbiAgICB0aGlzLm5hbWUgPSAnTm90Rm91bmRFcnJvcic7XG4gIH1cbn1cblxuLyoqIDQwMyDigJQgSW5zdWZmaWNpZW50IHBlcm1pc3Npb25zLiAqL1xuZXhwb3J0IGNsYXNzIEZvcmJpZGRlbkVycm9yIGV4dGVuZHMgQXBwRXJyb3Ige1xuICBjb25zdHJ1Y3RvcihtZXNzYWdlOiBzdHJpbmcpIHtcbiAgICBzdXBlcihnZXRTdGF0dXNGb3JFcnJvckNvZGUoRXJyb3JDb2RlLklOU1VGRklDSUVOVF9QRVJNSVNTSU9OUyksIEVycm9yQ29kZS5JTlNVRkZJQ0lFTlRfUEVSTUlTU0lPTlMsIG1lc3NhZ2UpO1xuICAgIHRoaXMubmFtZSA9ICdGb3JiaWRkZW5FcnJvcic7XG4gIH1cbn1cblxuLyoqIDQwMCDigJQgVmFsaWRhdGlvbiAvIGJhZCByZXF1ZXN0LiAqL1xuZXhwb3J0IGNsYXNzIFZhbGlkYXRpb25FcnJvciBleHRlbmRzIEFwcEVycm9yIHtcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nKSB7XG4gICAgc3VwZXIoZ2V0U3RhdHVzRm9yRXJyb3JDb2RlKEVycm9yQ29kZS5WQUxJREFUSU9OX0VSUk9SKSwgRXJyb3JDb2RlLlZBTElEQVRJT05fRVJST1IsIG1lc3NhZ2UpO1xuICAgIHRoaXMubmFtZSA9ICdWYWxpZGF0aW9uRXJyb3InO1xuICB9XG59XG5cbi8qKiA0MDkg4oCUIENvbmZsaWN0IC8gZHVwbGljYXRlLiBgY29kZWAgbmFycm93cyB0aGUgY29uZmxpY3QgZm9yIGNsaWVudHNcbiAqICAoZS5nLiBgUExVR0lOX1ZFUlNJT05fRlJPWkVOYCk7IGl0IG11c3QgYmUgYSA0MDktbWFwcGVkIGNvZGUuICovXG5leHBvcnQgY2xhc3MgQ29uZmxpY3RFcnJvciBleHRlbmRzIEFwcEVycm9yIHtcbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCBjb2RlOiBFcnJvckNvZGUgPSBFcnJvckNvZGUuQ09ORkxJQ1QpIHtcbiAgICBzdXBlcihnZXRTdGF0dXNGb3JFcnJvckNvZGUoRXJyb3JDb2RlLkNPTkZMSUNUKSwgY29kZSwgbWVzc2FnZSk7XG4gICAgdGhpcy5uYW1lID0gJ0NvbmZsaWN0RXJyb3InO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/helpers/content-disposition.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `Content-Disposition: attachment` for a download whose file name is built
+ * from stored or request data (a plugin name, a version, a report period). Every
+ * character outside `[A-Za-z0-9._-]` becomes `_`, so a quote, a CR/LF or a
+ * path separator can never break out of the header or the file name.
+ *
+ * In api-core rather than in one service because it is a header-injection guard with
+ * several callers (plugin's SBOM and scan downloads, reporting's report PDFs). A second
+ * copy of a sanitizer is a copy that gets a fix the other one does not.
+ */
+/** A header-safe file name (at most 200 characters, never empty). */
+export declare function safeFileName(name: string): string;
+/** The full header value for downloading `name` as an attachment. */
+export declare function attachmentDisposition(name: string): string;

package/lib/helpers/content-disposition.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * `Content-Disposition: attachment` for a download whose file name is built
+ * from stored or request data (a plugin name, a version, a report period). Every
+ * character outside `[A-Za-z0-9._-]` becomes `_`, so a quote, a CR/LF or a
+ * path separator can never break out of the header or the file name.
+ *
+ * In api-core rather than in one service because it is a header-injection guard with
+ * several callers (plugin's SBOM and scan downloads, reporting's report PDFs). A second
+ * copy of a sanitizer is a copy that gets a fix the other one does not.
+ */
+/** A header-safe file name (at most 200 characters, never empty). */
+export function safeFileName(name) {
+    const cleaned = name.replace(/[^A-Za-z0-9._-]/g, '_').replace(/^\.+/, '_').slice(0, 200);
+    return cleaned || 'download';
+}
+/** The full header value for downloading `name` as an attachment. */
+export function attachmentDisposition(name) {
+    return `attachment; filename="${safeFileName(name)}"`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/helpers/index.d.ts

@@ -4,3 +4,4 @@ export { loadAndRestore, loadAndPurge, type RestorableService, type PurgeableSer
 export * from './sse-helpers.js';
 export * from './org-hierarchy.js';
 export { fetchParentOrgId, fetchOrgDescendants, fetchOrgNames, fetchOrgMembership, } from './org-hierarchy-http.js';
+export * from './content-disposition.js';

package/lib/helpers/index.js

@@ -6,4 +6,5 @@ export { loadAndRestore, loadAndPurge, } from './restore-helpers.js';
 export * from './sse-helpers.js';
 export * from './org-hierarchy.js';
 export { fetchParentOrgId, fetchOrgDescendants, fetchOrgNames, fetchOrgMembership, } from './org-hierarchy-http.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsT0FBTyxFQUNMLDRCQUE0QixFQUM1QiwwQkFBMEIsRUFDMUIsZ0JBQWdCLEVBQ2hCLHVCQUF1QixFQUN2QixpQkFBaUIsR0FLbEIsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQ0wsY0FBYyxFQUNkLFlBQVksR0FLYixNQUFNLHNCQUFzQixDQUFDO0FBQzlCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLG1CQUFtQixFQUNuQixhQUFhLEVBQ2Isa0JBQWtCLEdBQ25CLE1BQU0seUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9jcnVkLWhlbHBlcnMuanMnO1xuZXhwb3J0IHtcbiAgcmVxdWlyZVZpc2liaWxpdHlXcml0ZUFjY2VzcyxcbiAgY2hlY2tWaXNpYmlsaXR5V3JpdGVBY2Nlc3MsXG4gIGNoZWNrV3JpdGVBY2Nlc3MsXG4gIHJlamVjdEZvcmJpZGRlbkJ1bGtSb3dzLFxuICByZXNvbHZlVmlzaWJpbGl0eSxcbiAgdHlwZSBWaXNpYmlsaXR5V3JpdGVUYXJnZXQsXG4gIHR5cGUgVmlzaWJpbGl0eVdyaXRlVmVyZGljdCxcbiAgdHlwZSBXcml0ZUFjY2VzcyxcbiAgdHlwZSBCdWxrV3JpdGVSb3csXG59IGZyb20gJy4vYWNjZXNzLWhlbHBlcnMuanMnO1xuZXhwb3J0IHtcbiAgbG9hZEFuZFJlc3RvcmUsXG4gIGxvYWRBbmRQdXJnZSxcbiAgdHlwZSBSZXN0b3JhYmxlU2VydmljZSxcbiAgdHlwZSBQdXJnZWFibGVTZXJ2aWNlLFxuICB0eXBlIFRvbWJzdG9uZUF1dGhvcml6ZXIsXG4gIHR5cGUgVG9tYnN0b25lUm91dGVPcHRpb25zLFxufSBmcm9tICcuL3Jlc3RvcmUtaGVscGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NzZS1oZWxwZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vb3JnLWhpZXJhcmNoeS5qcyc7XG5leHBvcnQge1xuICBmZXRjaFBhcmVudE9yZ0lkLFxuICBmZXRjaE9yZ0Rlc2NlbmRhbnRzLFxuICBmZXRjaE9yZ05hbWVzLFxuICBmZXRjaE9yZ01lbWJlcnNoaXAsXG59IGZyb20gJy4vb3JnLWhpZXJhcmNoeS1odHRwLmpzJztcbiJdfQ==
+export * from './content-disposition.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsT0FBTyxFQUNMLDRCQUE0QixFQUM1QiwwQkFBMEIsRUFDMUIsZ0JBQWdCLEVBQ2hCLHVCQUF1QixFQUN2QixpQkFBaUIsR0FLbEIsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQ0wsY0FBYyxFQUNkLFlBQVksR0FLYixNQUFNLHNCQUFzQixDQUFDO0FBQzlCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLG1CQUFtQixFQUNuQixhQUFhLEVBQ2Isa0JBQWtCLEdBQ25CLE1BQU0seUJBQXlCLENBQUM7QUFDakMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2NydWQtaGVscGVycy5qcyc7XG5leHBvcnQge1xuICByZXF1aXJlVmlzaWJpbGl0eVdyaXRlQWNjZXNzLFxuICBjaGVja1Zpc2liaWxpdHlXcml0ZUFjY2VzcyxcbiAgY2hlY2tXcml0ZUFjY2VzcyxcbiAgcmVqZWN0Rm9yYmlkZGVuQnVsa1Jvd3MsXG4gIHJlc29sdmVWaXNpYmlsaXR5LFxuICB0eXBlIFZpc2liaWxpdHlXcml0ZVRhcmdldCxcbiAgdHlwZSBWaXNpYmlsaXR5V3JpdGVWZXJkaWN0LFxuICB0eXBlIFdyaXRlQWNjZXNzLFxuICB0eXBlIEJ1bGtXcml0ZVJvdyxcbn0gZnJvbSAnLi9hY2Nlc3MtaGVscGVycy5qcyc7XG5leHBvcnQge1xuICBsb2FkQW5kUmVzdG9yZSxcbiAgbG9hZEFuZFB1cmdlLFxuICB0eXBlIFJlc3RvcmFibGVTZXJ2aWNlLFxuICB0eXBlIFB1cmdlYWJsZVNlcnZpY2UsXG4gIHR5cGUgVG9tYnN0b25lQXV0aG9yaXplcixcbiAgdHlwZSBUb21ic3RvbmVSb3V0ZU9wdGlvbnMsXG59IGZyb20gJy4vcmVzdG9yZS1oZWxwZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3NlLWhlbHBlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9vcmctaGllcmFyY2h5LmpzJztcbmV4cG9ydCB7XG4gIGZldGNoUGFyZW50T3JnSWQsXG4gIGZldGNoT3JnRGVzY2VuZGFudHMsXG4gIGZldGNoT3JnTmFtZXMsXG4gIGZldGNoT3JnTWVtYmVyc2hpcCxcbn0gZnJvbSAnLi9vcmctaGllcmFyY2h5LWh0dHAuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZW50LWRpc3Bvc2l0aW9uLmpzJztcbiJdfQ==

package/lib/services/index.d.ts

@@ -1,6 +1,6 @@
 export { exchangeApiKey, resetApiKeyExchangeCache, ApiKeyRejectedError, ApiKeyExchangeUnavailableError, } from './api-key-exchange.js';
 export { createCacheService, type RedisCacheClient, type CacheInvalidationMessage, type CacheInvalidationBus, type RedisInvalidationClient, CacheService, } from './cache-service.js';
-export { withLeaderLock, createEnvRedisLock, type LockRedis, } from './leader-lock.js';
+export { withLeaderLock, createEnvRedisLock, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS, type LockRedis, type LeaderLockRun, type LeaderLockOptions, type LeaderLockAbortReason, } from './leader-lock.js';
 export { sendSystemNotification, SYSTEM_NOTIFY_PATH, type SystemNotification, } from './system-notification.js';
 export { createScheduler, type SchedulerOptions, type Scheduler, } from './scheduler.js';
 export { createComplianceClient, type ComplianceCheckResult, type ComplianceViolation, } from './compliance-client.js';

package/lib/services/index.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 export { exchangeApiKey, resetApiKeyExchangeCache, ApiKeyRejectedError, ApiKeyExchangeUnavailableError, } from './api-key-exchange.js';
 export { createCacheService, CacheService, } from './cache-service.js';
-export { withLeaderLock, createEnvRedisLock, } from './leader-lock.js';
+export { withLeaderLock, createEnvRedisLock, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS, } from './leader-lock.js';
 export { sendSystemNotification, SYSTEM_NOTIFY_PATH, } from './system-notification.js';
 export { createScheduler, } from './scheduler.js';
 export { createComplianceClient, } from './compliance-client.js';
@@ -31,4 +31,4 @@ export { createMemorySseTicketStore, createEnvSseTicketStore, envSseTicketCaps,
 export { wireServiceSecurity, } from './service-boot.js';
 export { createWebhookChannel, createEmailChannel, createChannelRegistry, } from './notification-channels.js';
 export { createEcosystemNotifyClient, ECOSYSTEM_NOTIFY_PATH, } from './ecosystem-notify-client.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,8BAA8B,GAC/B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAKlB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,0BAA0B,GAK3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,kBAAkB,GAEnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,eAAe,GAGhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,sBAAsB,GAGvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,2BAA2B,EAE3B,8BAA8B,GAE/B,MAAM,+BAA+B,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,OAAO,EAGL,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,SAAS,GACV,MAAM,iBAAiB,CAAC;AACzB,iFAAiF;AACjF,8EAA8E;AAC9E,iFAAiF;AACjF,+DAA+D;AAC/D,OAAO,EACL,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAC3B,+EAA+E;AAC/E,yDAAyD;AACzD,OAAO,EACL,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,6BAA6B,GAG9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,aAAa,EACb,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,cAAc,GAGf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,WAAW,GAGZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,aAAa,EACb,wBAAwB,GAEzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,UAAU,EACV,gBAAgB,GAEjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,sBAAsB,EACtB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,GAIjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,GAMtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,GAEtB,MAAM,8BAA8B,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n  exchangeApiKey,\n  resetApiKeyExchangeCache,\n  ApiKeyRejectedError,\n  ApiKeyExchangeUnavailableError,\n} from './api-key-exchange.js';\nexport {\n  createCacheService,\n  type RedisCacheClient,\n  type CacheInvalidationMessage,\n  type CacheInvalidationBus,\n  type RedisInvalidationClient,\n  CacheService,\n} from './cache-service.js';\nexport {\n  withLeaderLock,\n  createEnvRedisLock,\n  leaderLockKey,\n  DEFAULT_LEADER_LOCK_TTL_MS,\n  type LockRedis,\n  type LeaderLockRun,\n  type LeaderLockOptions,\n  type LeaderLockAbortReason,\n} from './leader-lock.js';\nexport {\n  sendSystemNotification,\n  SYSTEM_NOTIFY_PATH,\n  type SystemNotification,\n} from './system-notification.js';\nexport {\n  createScheduler,\n  type SchedulerOptions,\n  type Scheduler,\n} from './scheduler.js';\nexport {\n  createComplianceClient,\n  type ComplianceCheckResult,\n  type ComplianceViolation,\n} from './compliance-client.js';\nexport {\n  pluginRunsOwnImage,\n  pluginComplianceTags,\n  derivePluginImageCompliance,\n  type PluginComplianceAttributes,\n  PLUGIN_IMAGE_COMPLIANCE_FIELDS,\n  type PluginImageRow,\n} from '../utils/plugin-compliance.js';\nexport * from './compliance-event-subscriber.js';\nexport {\n  type EntityEvent,\n  type EntityEventSubscriber,\n  entityEvents,\n} from './entity-events.js';\nexport {\n  destroySharedHttpAgents,\n  createSafeClient,\n  ResponseTooLargeError,\n  InternalHttpClient,\n} from './http-client.js';\nexport {\n  setPlatformJwksCache,\n  JwksUnavailableError,\n  UnknownKidError,\n  JwksCache,\n} from './jwks-cache.js';\n// Service-key internals stay internal. The package surface is the verify/inspect\n// side that platform's JWT options and the auth middleware need; key MATERIAL\n// handling (`signServiceJwt`, the bundle, the test reset hook) is reachable only\n// by deep import from inside api-core and its testing helpers.\nexport {\n  isServiceKid,\n  serviceIdentity,\n  verifyServiceJwt,\n} from './service-keys.js';\n// The breaker is wired by the shared HTTP client; services consume its EFFECT,\n// not the class. Only the operational surface is public.\nexport {\n  resetCircuitBreakers,\n} from './circuit-breaker.js';\nexport {\n  createEnvRedisDurableEventBus,\n  type EventSubscription,\n  type DurableEventBus,\n} from './durable-event-bus.js';\nexport {\n  getErrorRetryDecision,\n} from './retry-strategy.js';\nexport type {\n  RetryConfig,\n} from './retry-strategy.js';\nexport {\n  nextBackoffMs,\n  retryForever,\n} from './retry-forever.js';\nexport {\n  getQuotaServiceAuthHeader,\n  createQuotaService,\n  incrementQuota,\n  reserveQuota,\n  sendQuotaReserveDenied,\n  decrementQuota,\n  type QuotaReserveResult,\n  type QuotaService,\n} from './quota.js';\nexport {\n  createRemoteAuditClient,\n  wireAuthzDenialAuditor,\n  recordAudit,\n  type RemoteAuditEvent,\n  type RemoteAuditClient,\n} from './remote-audit-client.js';\nexport {\n  auditSpoolKey,\n  createEnvRedisAuditSpool,\n  type AuditSpool,\n} from './audit-spool.js';\nexport {\n  resolveRedisConnection,\n  describeRedisConnection,\n  createRedisClient,\n  createEnvRedisClient,\n  createRedisReadyGate,\n  incrWindow,\n  RedisConfigError,\n  type RedisEvalClient,\n} from './env-redis.js';\nexport {\n  createRedisTokenRevocationStore,\n  createEnvRedisTokenRevocationStore,\n  publishTokenRevocation,\n  publishSessionRevocation,\n  publishCredentialRevocation,\n} from './token-revocation.js';\nexport {\n  createMemorySseTicketStore,\n  createEnvSseTicketStore,\n  envSseTicketCaps,\n  type EnvSseTicketStoreConfig,\n  type SseTicketStore,\n  type SseTicketStoreConfig,\n} from './sse-ticket-store.js';\nexport {\n  wireServiceSecurity,\n} from './service-boot.js';\nexport {\n  createWebhookChannel,\n  createEmailChannel,\n  createChannelRegistry,\n  type NotificationPriority,\n  type NotificationMessage,\n  type ChannelTarget,\n  type DeliveryResult,\n  type NotificationChannel,\n} from './notification-channels.js';\nexport {\n  createEcosystemNotifyClient,\n  ECOSYSTEM_NOTIFY_PATH,\n  type EcosystemNotifyClient,\n} from './ecosystem-notify-client.js';\n"]}

package/lib/services/leader-lock.d.ts

@@ -22,15 +22,58 @@ export interface LockRedis extends ReadyAwareRedis {
  * either method. Never throws.
  */
 export declare function closeLeaderLock(redis: LockRedis | null | undefined): Promise<void>;
+/**
+ * Default lock lifetime — a CRASH-RECOVERY window, not a run-duration cover.
+ *
+ * The holder heartbeats (compare-and-PEXPIRE every `ttlMs / 3`) for as long as
+ * `fn` runs, so a six-hour job holds a two-minute lock perfectly well. What the
+ * TTL actually decides is how long a job stays BLOCKED after the pod holding it
+ * dies without releasing — the key simply sits there until it expires. Sizing the
+ * TTL to the expected run time (which is what several callers used to do) turned a
+ * crashed pod into hours of silent inactivity.
+ *
+ * Two minutes leaves three missed heartbeats of slack, so an event-loop stall or a
+ * brief Redis blip does not hand the lock to a second pod mid-run, while recovery
+ * after a real crash is bounded at two minutes.
+ */
+export declare const DEFAULT_LEADER_LOCK_TTL_MS = 120000;
+/**
+ * The one way to build a leader-lock key: `<service>:<job>:leader`.
+ *
+ * Four conventions had grown up — `plugin:vuln-rescan:leader`,
+ * `platform:leader:org-purge`, a bare `ecosystem-stats:leader`, and billing's
+ * unnamespaced `subscription-lifecycle` — which meant no single glob found every
+ * lock. `KEYS '*:leader'` missed billing's three entirely, so an operator asking
+ * "what is held right now" got a partial answer. The env Redis client sets no
+ * `keyPrefix`, so these share one flat keyspace with cache, BullMQ and spool keys;
+ * the `<service>:` segment is what keeps them apart.
+ */
+export declare function leaderLockKey(service: string, job: string): string;
+/** Why a leader-locked run was told to stop. */
+export type LeaderLockAbortReason = 'lock-lost' | 'shutdown';
 /** What a leader-locked run is told while it runs. */
 export interface LeaderLockRun {
     /**
      * Aborted when the lock is LOST mid-run (a heartbeat found another holder, or
-     * the key gone). Long runs should check it between units of work and stop —
-     * past that point another pod may be doing the same work.
+     * the key gone), or when the caller is SHUTTING DOWN. Long runs must check it
+     * between units of work and return: past a lock loss another pod may be doing
+     * the same work, and on shutdown returning promptly is what releases the lock
+     * instead of leaving it to expire.
+     *
+     * `signal.reason` is a {@link LeaderLockAbortReason}.
      */
     signal: AbortSignal;
 }
+/** Caller-supplied controls for {@link withLeaderLock}. */
+export interface LeaderLockOptions {
+    /**
+     * Aborted by the caller to ask a running job to stop — a scheduler's `stop()`
+     * on shutdown. Merged into {@link LeaderLockRun.signal}, so a signal-aware `fn`
+     * returns and the lock is released in the `finally` rather than lingering for
+     * the rest of the TTL.
+     */
+    signal?: AbortSignal;
+}
 /**
  * Run `fn` only if this process wins a short-lived distributed lock — the
  * across-pods "single runner" guard for periodic jobs (digest flushes, etc.).
@@ -46,10 +89,20 @@ export interface LeaderLockRun {
  * If Redis can't be reached the run is skipped (returns false) rather than
  * rejecting — callers are timers, and a Redis blip must not crash the process.
  *
+ * EVERY outcome is counted, because they mean very different things and the
+ * difference used to be visible only in a log line:
+ *  - `leader_lock_acquired_total` — this pod ran the window. A job whose count
+ *    stays flat is not running ANYWHERE, which is the condition worth alerting on.
+ *  - `leader_lock_contended_total` — another pod holds it. Healthy and expected
+ *    with replicas > 1; exactly one acquire per window across the fleet.
+ *  - `leader_lock_unavailable_total` — Redis unreachable, so NOBODY ran this
+ *    window. A Redis blip silently stopping every sweep fleet-wide was previously
+ *    a WARN log and nothing else.
+ *
  * @returns true if we held the lock and ran `fn`; false if another holder did or
  *   the lock couldn't be taken.
  */
-export declare function withLeaderLock(redis: LockRedis, key: string, ttlMs: number, fn: (run: LeaderLockRun) => Promise<void>): Promise<boolean>;
+export declare function withLeaderLock(redis: LockRedis, key: string, ttlMs: number, fn: (run: LeaderLockRun) => Promise<void>, opts?: LeaderLockOptions): Promise<boolean>;
 /**
  * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
  * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to

package/lib/services/leader-lock.js

@@ -35,6 +35,35 @@ const RELEASE_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return r
 const EXTEND_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("pexpire", KEYS[1], ARGV[2]) else return 0 end';
 /** Longest a run waits for a not-yet-connected client before skipping the window. */
 const LOCK_READY_TIMEOUT_MS = 10_000;
+/**
+ * Default lock lifetime — a CRASH-RECOVERY window, not a run-duration cover.
+ *
+ * The holder heartbeats (compare-and-PEXPIRE every `ttlMs / 3`) for as long as
+ * `fn` runs, so a six-hour job holds a two-minute lock perfectly well. What the
+ * TTL actually decides is how long a job stays BLOCKED after the pod holding it
+ * dies without releasing — the key simply sits there until it expires. Sizing the
+ * TTL to the expected run time (which is what several callers used to do) turned a
+ * crashed pod into hours of silent inactivity.
+ *
+ * Two minutes leaves three missed heartbeats of slack, so an event-loop stall or a
+ * brief Redis blip does not hand the lock to a second pod mid-run, while recovery
+ * after a real crash is bounded at two minutes.
+ */
+export const DEFAULT_LEADER_LOCK_TTL_MS = 120_000;
+/**
+ * The one way to build a leader-lock key: `<service>:<job>:leader`.
+ *
+ * Four conventions had grown up — `plugin:vuln-rescan:leader`,
+ * `platform:leader:org-purge`, a bare `ecosystem-stats:leader`, and billing's
+ * unnamespaced `subscription-lifecycle` — which meant no single glob found every
+ * lock. `KEYS '*:leader'` missed billing's three entirely, so an operator asking
+ * "what is held right now" got a partial answer. The env Redis client sets no
+ * `keyPrefix`, so these share one flat keyspace with cache, BullMQ and spool keys;
+ * the `<service>:` segment is what keeps them apart.
+ */
+export function leaderLockKey(service, job) {
+    return `${service}:${job}:leader`;
+}
 /**
  * Run `fn` only if this process wins a short-lived distributed lock — the
  * across-pods "single runner" guard for periodic jobs (digest flushes, etc.).
@@ -50,10 +79,23 @@ const LOCK_READY_TIMEOUT_MS = 10_000;
  * If Redis can't be reached the run is skipped (returns false) rather than
  * rejecting — callers are timers, and a Redis blip must not crash the process.
  *
+ * EVERY outcome is counted, because they mean very different things and the
+ * difference used to be visible only in a log line:
+ *  - `leader_lock_acquired_total` — this pod ran the window. A job whose count
+ *    stays flat is not running ANYWHERE, which is the condition worth alerting on.
+ *  - `leader_lock_contended_total` — another pod holds it. Healthy and expected
+ *    with replicas > 1; exactly one acquire per window across the fleet.
+ *  - `leader_lock_unavailable_total` — Redis unreachable, so NOBODY ran this
+ *    window. A Redis blip silently stopping every sweep fleet-wide was previously
+ *    a WARN log and nothing else.
+ *
  * @returns true if we held the lock and ran `fn`; false if another holder did or
  *   the lock couldn't be taken.
  */
-export async function withLeaderLock(redis, key, ttlMs, fn) {
+export async function withLeaderLock(redis, key, ttlMs, fn, opts = {}) {
+    // Asked to stop before we even tried: don't take a lock we are about to drop.
+    if (opts.signal?.aborted)
+        return false;
     const token = randomUUID();
     let acquired;
     try {
@@ -70,11 +112,24 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
         lockLogger.warn('Leader lock unavailable; skipping this run', {
             key, error: errorMessage(err),
         });
+        emitCounter('leader_lock_unavailable_total', { key });
         return false;
     }
-    if (acquired !== 'OK')
+    if (acquired !== 'OK') {
+        emitCounter('leader_lock_contended_total', { key });
         return false;
+    }
+    emitCounter('leader_lock_acquired_total', { key });
     const lost = new AbortController();
+    // Shutdown is merged into the SAME signal a lock loss uses: from `fn`'s point of
+    // view both mean "stop between units of work and return". `signal.reason` says
+    // which. Registered with `once` so a long-lived caller signal doesn't retain
+    // this controller after the run.
+    const onExternalAbort = () => {
+        if (!lost.signal.aborted)
+            lost.abort('shutdown');
+    };
+    opts.signal?.addEventListener('abort', onExternalAbort, { once: true });
     let heartbeat;
     if (typeof redis.eval === 'function') {
         const evalFn = redis.eval.bind(redis);
@@ -83,7 +138,7 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
                 if (Number(extended) !== 1 && !lost.signal.aborted) {
                     lockLogger.warn('Leader lock lost mid-run (another holder, or the key expired)', { key });
                     emitCounter('leader_lock_lost_total', { key });
-                    lost.abort();
+                    lost.abort('lock-lost');
                 }
             }).catch((err) => {
                 // A blip: the next beat retries; the TTL still covers this interval.
@@ -98,6 +153,7 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     finally {
         if (heartbeat)
             clearInterval(heartbeat);
+        opts.signal?.removeEventListener('abort', onExternalAbort);
         // Release only if the lock is still ours — if our run overran the TTL and
         // another holder took over, releasing here would free their lock early.
         // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without
@@ -153,4 +209,4 @@ export async function releaseSharedEnvLock() {
     sharedLock = undefined;
     await closeLeaderLock(client);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leader-lock.js","sourceRoot":"","sources":["../../src/services/leader-lock.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisClient, whenRedisReady, type ReadyAwareRedis } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst lockLogger = createLogger('leader-lock');\n\n/**\n * Minimal Redis client surface needed for a leader lock (a subset of ioredis).\n * `set` is variadic so callers can pass `'PX', ttl, 'NX'`.\n */\nexport interface LockRedis extends ReadyAwareRedis {\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  /** Optional Lua eval (ioredis has it). When present, release uses an atomic\n   *  compare-and-delete so a lapsed holder can't free a successor's lock. */\n  eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;\n  /** Graceful close (ioredis `quit`) — called on shutdown so the connection\n   *  doesn't keep the event loop alive. */\n  quit?(): Promise<unknown>;\n  /** Immediate close (ioredis `disconnect`) — the fallback if `quit` fails. */\n  disconnect?(): void;\n}\n\n/**\n * Best-effort close of a leader-lock Redis client on shutdown. Prefers graceful\n * `quit`; falls back to `disconnect`. No-op for a null client / one without\n * either method. Never throws.\n */\nexport async function closeLeaderLock(redis: LockRedis | null | undefined): Promise<void> {\n  if (!redis) return;\n  try {\n    if (typeof redis.quit === 'function') { await redis.quit(); return; }\n  } catch {\n    // fall through to disconnect\n  }\n  try { redis.disconnect?.(); } catch { /* best-effort */ }\n}\n\n/** Atomic \"delete only if I still own it\" — closes the get-then-del race where\n *  the lock expires and is re-acquired between the two calls. */\nconst RELEASE_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"del\", KEYS[1]) else return 0 end';\n\n/** Atomic \"extend only if I still own it\" — the heartbeat. */\nconst EXTEND_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"pexpire\", KEYS[1], ARGV[2]) else return 0 end';\n\n/** Longest a run waits for a not-yet-connected client before skipping the window. */\nconst LOCK_READY_TIMEOUT_MS = 10_000;\n\n/** What a leader-locked run is told while it runs. */\nexport interface LeaderLockRun {\n  /**\n   * Aborted when the lock is LOST mid-run (a heartbeat found another holder, or\n   * the key gone). Long runs should check it between units of work and stop —\n   * past that point another pod may be doing the same work.\n   */\n  signal: AbortSignal;\n}\n\n/**\n * Run `fn` only if this process wins a short-lived distributed lock — the\n * across-pods \"single runner\" guard for periodic jobs (digest flushes, etc.).\n *\n * Uses `SET key token NX PX ttl`, so exactly one holder runs per window and the\n * lock auto-expires if that holder dies mid-run (no stuck lock). While `fn`\n * runs, the holder HEARTBEATS (compare-and-PEXPIRE every `ttlMs / 3`), so a run\n * that outlasts `ttlMs` keeps the lock instead of silently letting a second pod\n * start the same work; a heartbeat that finds the lock gone aborts\n * `run.signal`. The lock is released on completion, but only if we still own\n * it — a slower predecessor never deletes a successor's lock.\n *\n * If Redis can't be reached the run is skipped (returns false) rather than\n * rejecting — callers are timers, and a Redis blip must not crash the process.\n *\n * @returns true if we held the lock and ran `fn`; false if another holder did or\n *   the lock couldn't be taken.\n */\nexport async function withLeaderLock(\n  redis: LockRedis,\n  key: string,\n  ttlMs: number,\n  fn: (run: LeaderLockRun) => Promise<void>,\n): Promise<boolean> {\n  const token = randomUUID();\n  let acquired: unknown;\n  try {\n    // The env client has no offline queue: a SET before the first connection\n    // completes is rejected, which made the FIRST tick after every boot a\n    // guaranteed skip. Wait (bounded) for readiness first.\n    await whenRedisReady(redis, Math.min(LOCK_READY_TIMEOUT_MS, Math.max(1, ttlMs)));\n    acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');\n  } catch (err) {\n    // Redis unreachable (including before the first connection completes): no\n    // pod can prove it's the leader, so nobody runs this window. Skipping is\n    // the safe side — running here could duplicate destructive work across pods.\n    lockLogger.warn('Leader lock unavailable; skipping this run', {\n      key, error: errorMessage(err),\n    });\n    return false;\n  }\n  if (acquired !== 'OK') return false;\n\n  const lost = new AbortController();\n  let heartbeat: NodeJS.Timeout | undefined;\n  if (typeof redis.eval === 'function') {\n    const evalFn = redis.eval.bind(redis);\n    heartbeat = setInterval(() => {\n      evalFn(EXTEND_IF_OWNER, 1, key, token, ttlMs).then((extended) => {\n        if (Number(extended) !== 1 && !lost.signal.aborted) {\n          lockLogger.warn('Leader lock lost mid-run (another holder, or the key expired)', { key });\n          emitCounter('leader_lock_lost_total', { key });\n          lost.abort();\n        }\n      }).catch((err) => {\n        // A blip: the next beat retries; the TTL still covers this interval.\n        lockLogger.debug('Leader lock heartbeat failed', { key, error: errorMessage(err) });\n      });\n    }, Math.max(1, Math.floor(ttlMs / 3)));\n    heartbeat.unref?.();\n  }\n\n  try {\n    await fn({ signal: lost.signal });\n  } finally {\n    if (heartbeat) clearInterval(heartbeat);\n    // Release only if the lock is still ours — if our run overran the TTL and\n    // another holder took over, releasing here would free their lock early.\n    // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without\n    // eval (the small non-atomic window is TTL-bounded).\n    try {\n      if (typeof redis.eval === 'function') {\n        await redis.eval(RELEASE_IF_OWNER, 1, key, token);\n      } else if ((await redis.get(key)) === token) {\n        await redis.del(key);\n      }\n    } catch {\n      // Best-effort: the TTL expires the lock regardless.\n    }\n  }\n  return true;\n}\n\n/**\n * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /\n * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to\n * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to\n * running on every pod (the atomic guards it wraps must still make that safe).\n * The client is a real ioredis instance; ioredis exposes `set`/`get`/`del`/`eval`,\n * satisfying `LockRedis` including the atomic CAS release.\n */\nexport function createEnvRedisLock(): LockRedis | null {\n  const inst = createEnvRedisClient<LockRedis>('leader-lock');\n  if (inst) lockLogger.info('Redis leader-lock client initialized');\n  return inst;\n}\n\n// One env-configured lock client per process, shared by every scheduler that\n// asks for a lock without supplying its own client. Reference-counted so the\n// connection is closed when the last such scheduler stops.\nlet sharedLock: LockRedis | null | undefined;\nlet sharedLockUsers = 0;\n\n/** Take a reference on the shared env lock client (`null` when Redis isn't configured). */\nexport function acquireSharedEnvLock(): LockRedis | null {\n  if (sharedLock === undefined) sharedLock = createEnvRedisLock();\n  sharedLockUsers++;\n  return sharedLock;\n}\n\n/** Drop a reference taken by {@link acquireSharedEnvLock}; the last one closes the client. */\nexport async function releaseSharedEnvLock(): Promise<void> {\n  if (sharedLockUsers === 0) return;\n  sharedLockUsers--;\n  if (sharedLockUsers > 0) return;\n  const client = sharedLock;\n  sharedLock = undefined;\n  await closeLeaderLock(client);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leader-lock.js","sourceRoot":"","sources":["../../src/services/leader-lock.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisClient, whenRedisReady, type ReadyAwareRedis } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst lockLogger = createLogger('leader-lock');\n\n/**\n * Minimal Redis client surface needed for a leader lock (a subset of ioredis).\n * `set` is variadic so callers can pass `'PX', ttl, 'NX'`.\n */\nexport interface LockRedis extends ReadyAwareRedis {\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  /** Optional Lua eval (ioredis has it). When present, release uses an atomic\n   *  compare-and-delete so a lapsed holder can't free a successor's lock. */\n  eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;\n  /** Graceful close (ioredis `quit`) — called on shutdown so the connection\n   *  doesn't keep the event loop alive. */\n  quit?(): Promise<unknown>;\n  /** Immediate close (ioredis `disconnect`) — the fallback if `quit` fails. */\n  disconnect?(): void;\n}\n\n/**\n * Best-effort close of a leader-lock Redis client on shutdown. Prefers graceful\n * `quit`; falls back to `disconnect`. No-op for a null client / one without\n * either method. Never throws.\n */\nexport async function closeLeaderLock(redis: LockRedis | null | undefined): Promise<void> {\n  if (!redis) return;\n  try {\n    if (typeof redis.quit === 'function') { await redis.quit(); return; }\n  } catch {\n    // fall through to disconnect\n  }\n  try { redis.disconnect?.(); } catch { /* best-effort */ }\n}\n\n/** Atomic \"delete only if I still own it\" — closes the get-then-del race where\n *  the lock expires and is re-acquired between the two calls. */\nconst RELEASE_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"del\", KEYS[1]) else return 0 end';\n\n/** Atomic \"extend only if I still own it\" — the heartbeat. */\nconst EXTEND_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"pexpire\", KEYS[1], ARGV[2]) else return 0 end';\n\n/** Longest a run waits for a not-yet-connected client before skipping the window. */\nconst LOCK_READY_TIMEOUT_MS = 10_000;\n\n/**\n * Default lock lifetime — a CRASH-RECOVERY window, not a run-duration cover.\n *\n * The holder heartbeats (compare-and-PEXPIRE every `ttlMs / 3`) for as long as\n * `fn` runs, so a six-hour job holds a two-minute lock perfectly well. What the\n * TTL actually decides is how long a job stays BLOCKED after the pod holding it\n * dies without releasing — the key simply sits there until it expires. Sizing the\n * TTL to the expected run time (which is what several callers used to do) turned a\n * crashed pod into hours of silent inactivity.\n *\n * Two minutes leaves three missed heartbeats of slack, so an event-loop stall or a\n * brief Redis blip does not hand the lock to a second pod mid-run, while recovery\n * after a real crash is bounded at two minutes.\n */\nexport const DEFAULT_LEADER_LOCK_TTL_MS = 120_000;\n\n/**\n * The one way to build a leader-lock key: `<service>:<job>:leader`.\n *\n * Four conventions had grown up — `plugin:vuln-rescan:leader`,\n * `platform:leader:org-purge`, a bare `ecosystem-stats:leader`, and billing's\n * unnamespaced `subscription-lifecycle` — which meant no single glob found every\n * lock. `KEYS '*:leader'` missed billing's three entirely, so an operator asking\n * \"what is held right now\" got a partial answer. The env Redis client sets no\n * `keyPrefix`, so these share one flat keyspace with cache, BullMQ and spool keys;\n * the `<service>:` segment is what keeps them apart.\n */\nexport function leaderLockKey(service: string, job: string): string {\n  return `${service}:${job}:leader`;\n}\n\n/** Why a leader-locked run was told to stop. */\nexport type LeaderLockAbortReason = 'lock-lost' | 'shutdown';\n\n/** What a leader-locked run is told while it runs. */\nexport interface LeaderLockRun {\n  /**\n   * Aborted when the lock is LOST mid-run (a heartbeat found another holder, or\n   * the key gone), or when the caller is SHUTTING DOWN. Long runs must check it\n   * between units of work and return: past a lock loss another pod may be doing\n   * the same work, and on shutdown returning promptly is what releases the lock\n   * instead of leaving it to expire.\n   *\n   * `signal.reason` is a {@link LeaderLockAbortReason}.\n   */\n  signal: AbortSignal;\n}\n\n/** Caller-supplied controls for {@link withLeaderLock}. */\nexport interface LeaderLockOptions {\n  /**\n   * Aborted by the caller to ask a running job to stop — a scheduler's `stop()`\n   * on shutdown. Merged into {@link LeaderLockRun.signal}, so a signal-aware `fn`\n   * returns and the lock is released in the `finally` rather than lingering for\n   * the rest of the TTL.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Run `fn` only if this process wins a short-lived distributed lock — the\n * across-pods \"single runner\" guard for periodic jobs (digest flushes, etc.).\n *\n * Uses `SET key token NX PX ttl`, so exactly one holder runs per window and the\n * lock auto-expires if that holder dies mid-run (no stuck lock). While `fn`\n * runs, the holder HEARTBEATS (compare-and-PEXPIRE every `ttlMs / 3`), so a run\n * that outlasts `ttlMs` keeps the lock instead of silently letting a second pod\n * start the same work; a heartbeat that finds the lock gone aborts\n * `run.signal`. The lock is released on completion, but only if we still own\n * it — a slower predecessor never deletes a successor's lock.\n *\n * If Redis can't be reached the run is skipped (returns false) rather than\n * rejecting — callers are timers, and a Redis blip must not crash the process.\n *\n * EVERY outcome is counted, because they mean very different things and the\n * difference used to be visible only in a log line:\n *  - `leader_lock_acquired_total` — this pod ran the window. A job whose count\n *    stays flat is not running ANYWHERE, which is the condition worth alerting on.\n *  - `leader_lock_contended_total` — another pod holds it. Healthy and expected\n *    with replicas > 1; exactly one acquire per window across the fleet.\n *  - `leader_lock_unavailable_total` — Redis unreachable, so NOBODY ran this\n *    window. A Redis blip silently stopping every sweep fleet-wide was previously\n *    a WARN log and nothing else.\n *\n * @returns true if we held the lock and ran `fn`; false if another holder did or\n *   the lock couldn't be taken.\n */\nexport async function withLeaderLock(\n  redis: LockRedis,\n  key: string,\n  ttlMs: number,\n  fn: (run: LeaderLockRun) => Promise<void>,\n  opts: LeaderLockOptions = {},\n): Promise<boolean> {\n  // Asked to stop before we even tried: don't take a lock we are about to drop.\n  if (opts.signal?.aborted) return false;\n\n  const token = randomUUID();\n  let acquired: unknown;\n  try {\n    // The env client has no offline queue: a SET before the first connection\n    // completes is rejected, which made the FIRST tick after every boot a\n    // guaranteed skip. Wait (bounded) for readiness first.\n    await whenRedisReady(redis, Math.min(LOCK_READY_TIMEOUT_MS, Math.max(1, ttlMs)));\n    acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');\n  } catch (err) {\n    // Redis unreachable (including before the first connection completes): no\n    // pod can prove it's the leader, so nobody runs this window. Skipping is\n    // the safe side — running here could duplicate destructive work across pods.\n    lockLogger.warn('Leader lock unavailable; skipping this run', {\n      key, error: errorMessage(err),\n    });\n    emitCounter('leader_lock_unavailable_total', { key });\n    return false;\n  }\n  if (acquired !== 'OK') {\n    emitCounter('leader_lock_contended_total', { key });\n    return false;\n  }\n  emitCounter('leader_lock_acquired_total', { key });\n\n  const lost = new AbortController();\n  // Shutdown is merged into the SAME signal a lock loss uses: from `fn`'s point of\n  // view both mean \"stop between units of work and return\". `signal.reason` says\n  // which. Registered with `once` so a long-lived caller signal doesn't retain\n  // this controller after the run.\n  const onExternalAbort = (): void => {\n    if (!lost.signal.aborted) lost.abort('shutdown' satisfies LeaderLockAbortReason);\n  };\n  opts.signal?.addEventListener('abort', onExternalAbort, { once: true });\n\n  let heartbeat: NodeJS.Timeout | undefined;\n  if (typeof redis.eval === 'function') {\n    const evalFn = redis.eval.bind(redis);\n    heartbeat = setInterval(() => {\n      evalFn(EXTEND_IF_OWNER, 1, key, token, ttlMs).then((extended) => {\n        if (Number(extended) !== 1 && !lost.signal.aborted) {\n          lockLogger.warn('Leader lock lost mid-run (another holder, or the key expired)', { key });\n          emitCounter('leader_lock_lost_total', { key });\n          lost.abort('lock-lost' satisfies LeaderLockAbortReason);\n        }\n      }).catch((err) => {\n        // A blip: the next beat retries; the TTL still covers this interval.\n        lockLogger.debug('Leader lock heartbeat failed', { key, error: errorMessage(err) });\n      });\n    }, Math.max(1, Math.floor(ttlMs / 3)));\n    heartbeat.unref?.();\n  }\n\n  try {\n    await fn({ signal: lost.signal });\n  } finally {\n    if (heartbeat) clearInterval(heartbeat);\n    opts.signal?.removeEventListener('abort', onExternalAbort);\n    // Release only if the lock is still ours — if our run overran the TTL and\n    // another holder took over, releasing here would free their lock early.\n    // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without\n    // eval (the small non-atomic window is TTL-bounded).\n    try {\n      if (typeof redis.eval === 'function') {\n        await redis.eval(RELEASE_IF_OWNER, 1, key, token);\n      } else if ((await redis.get(key)) === token) {\n        await redis.del(key);\n      }\n    } catch {\n      // Best-effort: the TTL expires the lock regardless.\n    }\n  }\n  return true;\n}\n\n/**\n * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /\n * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to\n * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to\n * running on every pod (the atomic guards it wraps must still make that safe).\n * The client is a real ioredis instance; ioredis exposes `set`/`get`/`del`/`eval`,\n * satisfying `LockRedis` including the atomic CAS release.\n */\nexport function createEnvRedisLock(): LockRedis | null {\n  const inst = createEnvRedisClient<LockRedis>('leader-lock');\n  if (inst) lockLogger.info('Redis leader-lock client initialized');\n  return inst;\n}\n\n// One env-configured lock client per process, shared by every scheduler that\n// asks for a lock without supplying its own client. Reference-counted so the\n// connection is closed when the last such scheduler stops.\nlet sharedLock: LockRedis | null | undefined;\nlet sharedLockUsers = 0;\n\n/** Take a reference on the shared env lock client (`null` when Redis isn't configured). */\nexport function acquireSharedEnvLock(): LockRedis | null {\n  if (sharedLock === undefined) sharedLock = createEnvRedisLock();\n  sharedLockUsers++;\n  return sharedLock;\n}\n\n/** Drop a reference taken by {@link acquireSharedEnvLock}; the last one closes the client. */\nexport async function releaseSharedEnvLock(): Promise<void> {\n  if (sharedLockUsers === 0) return;\n  sharedLockUsers--;\n  if (sharedLockUsers > 0) return;\n  const client = sharedLock;\n  sharedLock = undefined;\n  await closeLeaderLock(client);\n}\n"]}

package/lib/services/scheduler.d.ts

@@ -1,4 +1,4 @@
-import { type LockRedis } from './leader-lock.js';
+import { type LeaderLockRun, type LockRedis } from './leader-lock.js';
 /**
  * Optional cross-pod single-runner lock for a scheduler's cycle. Without
  * `redis` the scheduler uses the process's shared env-configured lock client
@@ -16,8 +16,17 @@ export interface SchedulerOptions {
     name: string;
     /** Interval between cycles (ms). */
     intervalMs: number;
-    /** The work to run each cycle. Errors are caught + logged, never thrown. */
-    run: () => Promise<void>;
+    /**
+     * The work to run each cycle. Errors are caught + logged, never thrown.
+     *
+     * `run.signal` is aborted when a leader-locked cycle LOSES its lock mid-run, or
+     * when `stop()` is called. A job that iterates over units of work (orgs, repos,
+     * entities) must check it between units and return: past a lock loss another pod
+     * may be doing the same work, and on shutdown returning promptly is what
+     * releases the lock instead of leaving it to expire. Unlocked schedulers get a
+     * signal too — it fires on `stop()` only.
+     */
+    run: (run: LeaderLockRun) => Promise<void>;
     /** Run a cycle immediately when started. Default true. */
     runOnStart?: boolean;
     /** Delay before the first cycle (and before the interval begins), ms.
@@ -30,7 +39,14 @@ export interface SchedulerOptions {
 export interface Scheduler {
     /** Start the timer. Idempotent — repeated calls are no-ops. */
     start(): void;
-    /** Stop the timer (and cancel a pending startup delay). Safe before start. */
+    /**
+     * Stop the timer (and cancel a pending startup delay). Safe before start.
+     *
+     * Also ABORTS an in-flight cycle's `run.signal` and defers closing the shared
+     * lock client until that cycle settles: a running cycle used to keep its lock
+     * key until the TTL lapsed, so a rolling deploy mid-run parked the job for the
+     * rest of the TTL. A signal-aware `run` returns and the lock is released.
+     */
     stop(): void;
 }
 /**