@pipeline-builder/api-core 3.4.126 → 4.0.2

package/lib/openapi/routes/image-registry-routes.js

@@ -0,0 +1,98 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Image Registry'];
+const auth = [{ bearerAuth: [] }];
+/**
+ * OpenAPI definitions for the image-registry service (api/image-registry): the
+ * Docker-registry token endpoint (`/token`), the org-scoped image API
+ * (`/api/images`), and the admin API (`/api/admin`). Image read/write is gated by
+ * the `registry:read` / `registry:write` permissions.
+ */
+export function registerImageRegistryRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/token',
+        summary: 'Mint a Docker registry token',
+        description: 'OAuth2-style token endpoint for `docker`/`crane`/`buildctl` clients. Verifies Basic-auth creds (a platform JWT or user login) and issues a scoped bearer token for pull/push.',
+        tags,
+        responses: { 200: { description: 'Registry access token' }, 401: { description: 'Invalid credentials' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images',
+        summary: 'List images',
+        description: "List the organization's container images in the registry.",
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Image list' }, 403: { description: 'registry:read required' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images/{name}/tags',
+        summary: 'List image tags',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Tag list' }, 404: { description: 'Image not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images/{name}/manifests/{reference}',
+        summary: 'Get an image manifest',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'OCI manifest / index' }, 404: { description: 'Manifest not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/images/{name}/blobs/{digest}',
+        summary: 'Get an image blob',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Blob content' }, 404: { description: 'Blob not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/api/images/copy',
+        summary: 'Copy an image',
+        description: 'Server-side copy of an image between repositories. Requires both registry:read and registry:write.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Image copied' }, 403: { description: 'registry:read + registry:write required' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/api/images/{name}',
+        summary: 'Delete an image repository',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Repository deleted' }, 403: { description: 'registry:write required' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/api/images/{name}/manifests/{reference}',
+        summary: 'Delete an image manifest/tag',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Manifest deleted' }, 403: { description: 'registry:write required' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/api/admin/storage/{prefix}',
+        summary: 'Registry storage rollup',
+        description: 'Storage usage rollup under a prefix (registry:read).',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Storage usage' }, 403: { description: 'registry:read required' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/api/admin/gc',
+        summary: 'Run registry garbage collection',
+        description: 'Trigger blob/manifest garbage collection (registry:write).',
+        tags,
+        security: auth,
+        responses: { 202: { description: 'GC started' }, 403: { description: 'registry:write required' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-registry-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/image-registry-routes.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,IAAI,GAAG,CAAC,gBAAgB,CAAC,CAAC;AAChC,MAAM,IAAI,GAAG,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;AAElC;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B;IACzC,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,8BAA8B;QACvC,WAAW,EAAE,+KAA+K;QAC5L,IAAI;QACJ,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,uBAAuB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,qBAAqB,EAAE,EAAE;KAC1G,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,aAAa;QACnB,OAAO,EAAE,aAAa;QACtB,WAAW,EAAE,2DAA2D;QACxE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,wBAAwB,EAAE,EAAE;KAClG,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,yBAAyB;QAC/B,OAAO,EAAE,iBAAiB;QAC1B,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,iBAAiB,EAAE,EAAE;KACzF,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,0CAA0C;QAChD,OAAO,EAAE,uBAAuB;QAChC,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,sBAAsB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,oBAAoB,EAAE,EAAE;KACxG,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,mCAAmC;QACzC,OAAO,EAAE,mBAAmB;QAC5B,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,cAAc,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,gBAAgB,EAAE,EAAE;KAC5F,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,kBAAkB;QACxB,OAAO,EAAE,eAAe;QACxB,WAAW,EAAE,oGAAoG;QACjH,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,cAAc,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,yCAAyC,EAAE,EAAE;KACrH,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,QAAQ;QAChB,IAAI,EAAE,oBAAoB;QAC1B,OAAO,EAAE,4BAA4B;QACrC,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,oBAAoB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,yBAAyB,EAAE,EAAE;KAC3G,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,QAAQ;QAChB,IAAI,EAAE,0CAA0C;QAChD,OAAO,EAAE,8BAA8B;QACvC,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,yBAAyB,EAAE,EAAE;KACzG,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,6BAA6B;QACnC,OAAO,EAAE,yBAAyB;QAClC,WAAW,EAAE,sDAAsD;QACnE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,eAAe,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,wBAAwB,EAAE,EAAE;KACrG,CAAC,CAAC;IAEH,QAAQ,CAAC,YAAY,CAAC;QACpB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,iCAAiC;QAC1C,WAAW,EAAE,4DAA4D;QACzE,IAAI;QACJ,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,yBAAyB,EAAE,EAAE;KACnG,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Image Registry'];\nconst auth = [{ bearerAuth: [] }];\n\n/**\n * OpenAPI definitions for the image-registry service (api/image-registry): the\n * Docker-registry token endpoint (`/token`), the org-scoped image API\n * (`/api/images`), and the admin API (`/api/admin`). Image read/write is gated by\n * the `registry:read` / `registry:write` permissions.\n */\nexport function registerImageRegistryRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/token',\n    summary: 'Mint a Docker registry token',\n    description: 'OAuth2-style token endpoint for `docker`/`crane`/`buildctl` clients. Verifies Basic-auth creds (a platform JWT or user login) and issues a scoped bearer token for pull/push.',\n    tags,\n    responses: { 200: { description: 'Registry access token' }, 401: { description: 'Invalid credentials' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images',\n    summary: 'List images',\n    description: \"List the organization's container images in the registry.\",\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Image list' }, 403: { description: 'registry:read required' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images/{name}/tags',\n    summary: 'List image tags',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Tag list' }, 404: { description: 'Image not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images/{name}/manifests/{reference}',\n    summary: 'Get an image manifest',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'OCI manifest / index' }, 404: { description: 'Manifest not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/images/{name}/blobs/{digest}',\n    summary: 'Get an image blob',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Blob content' }, 404: { description: 'Blob not found' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/api/images/copy',\n    summary: 'Copy an image',\n    description: 'Server-side copy of an image between repositories. Requires both registry:read and registry:write.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Image copied' }, 403: { description: 'registry:read + registry:write required' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/api/images/{name}',\n    summary: 'Delete an image repository',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Repository deleted' }, 403: { description: 'registry:write required' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/api/images/{name}/manifests/{reference}',\n    summary: 'Delete an image manifest/tag',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Manifest deleted' }, 403: { description: 'registry:write required' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/api/admin/storage/{prefix}',\n    summary: 'Registry storage rollup',\n    description: 'Storage usage rollup under a prefix (registry:read).',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Storage usage' }, 403: { description: 'registry:read required' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/api/admin/gc',\n    summary: 'Run registry garbage collection',\n    description: 'Trigger blob/manifest garbage collection (registry:write).',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'GC started' }, 403: { description: 'registry:write required' } },\n  });\n}\n"]}

package/lib/openapi/routes/index.js

@@ -1,6 +1,8 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { registerAskRoutes } from './ask-routes.js';
 import { registerBillingRoutes } from './billing-routes.js';
+import { registerImageRegistryRoutes } from './image-registry-routes.js';
 import { registerMessageRoutes } from './message-routes.js';
 import { registerPipelineRoutes } from './pipeline-routes.js';
 import { registerPipelineTemplateRoutes } from './pipeline-template-routes.js';
@@ -11,11 +13,16 @@ import { registerQuotaRoutes } from './quota-routes.js';
  * Call this once during spec generation initialization.
  */
 export function registerAllRoutes() {
+    registerAskRoutes();
     registerBillingRoutes();
+    registerImageRegistryRoutes();
     registerMessageRoutes();
     registerPipelineRoutes();
     registerPipelineTemplateRoutes();
     registerPluginRoutes();
     registerQuotaRoutes();
+    // NOTE: compliance + reporting (large multi-router surfaces) and platform/auth
+    // are not yet registered — follow-on, and intentionally omitted rather than
+    // shipping inaccurate paths.
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvb3BlbmFwaS9yb3V0ZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUM5RCxPQUFPLEVBQUUsOEJBQThCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMvRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMxRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUV4RDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsaUJBQWlCO0lBQy9CLHFCQUFxQixFQUFFLENBQUM7SUFDeEIscUJBQXFCLEVBQUUsQ0FBQztJQUN4QixzQkFBc0IsRUFBRSxDQUFDO0lBQ3pCLDhCQUE4QixFQUFFLENBQUM7SUFDakMsb0JBQW9CLEVBQUUsQ0FBQztJQUN2QixtQkFBbUIsRUFBRSxDQUFDO0FBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHsgcmVnaXN0ZXJCaWxsaW5nUm91dGVzIH0gZnJvbSAnLi9iaWxsaW5nLXJvdXRlcy5qcyc7XG5pbXBvcnQgeyByZWdpc3Rlck1lc3NhZ2VSb3V0ZXMgfSBmcm9tICcuL21lc3NhZ2Utcm91dGVzLmpzJztcbmltcG9ydCB7IHJlZ2lzdGVyUGlwZWxpbmVSb3V0ZXMgfSBmcm9tICcuL3BpcGVsaW5lLXJvdXRlcy5qcyc7XG5pbXBvcnQgeyByZWdpc3RlclBpcGVsaW5lVGVtcGxhdGVSb3V0ZXMgfSBmcm9tICcuL3BpcGVsaW5lLXRlbXBsYXRlLXJvdXRlcy5qcyc7XG5pbXBvcnQgeyByZWdpc3RlclBsdWdpblJvdXRlcyB9IGZyb20gJy4vcGx1Z2luLXJvdXRlcy5qcyc7XG5pbXBvcnQgeyByZWdpc3RlclF1b3RhUm91dGVzIH0gZnJvbSAnLi9xdW90YS1yb3V0ZXMuanMnO1xuXG4vKipcbiAqIFJlZ2lzdGVyIGFsbCBPcGVuQVBJIHJvdXRlIGRlZmluaXRpb25zIHdpdGggdGhlIHNoYXJlZCByZWdpc3RyeS5cbiAqIENhbGwgdGhpcyBvbmNlIGR1cmluZyBzcGVjIGdlbmVyYXRpb24gaW5pdGlhbGl6YXRpb24uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZWdpc3RlckFsbFJvdXRlcygpOiB2b2lkIHtcbiAgcmVnaXN0ZXJCaWxsaW5nUm91dGVzKCk7XG4gIHJlZ2lzdGVyTWVzc2FnZVJvdXRlcygpO1xuICByZWdpc3RlclBpcGVsaW5lUm91dGVzKCk7XG4gIHJlZ2lzdGVyUGlwZWxpbmVUZW1wbGF0ZVJvdXRlcygpO1xuICByZWdpc3RlclBsdWdpblJvdXRlcygpO1xuICByZWdpc3RlclF1b3RhUm91dGVzKCk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/pipeline-routes.js

@@ -39,6 +39,15 @@ export function registerPipelineRoutes() {
         security: auth,
         responses: { 200: { description: 'Scorecard' }, 403: { description: 'Feature not enabled' }, 404: { description: 'Not found' } },
     });
+    registry.registerPath({
+        method: 'get',
+        path: '/pipelines/scorecard',
+        summary: 'Org-wide scorecard roll-up (software-health leaderboard)',
+        description: 'Grades every pipeline in the organization and returns a ranked leaderboard plus aggregate stats (pipeline count, average score, grade distribution). Bounded per request. Requires the `advanced_reporting` feature.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Org-wide scorecard roll-up' }, 403: { description: 'Feature not enabled' } },
+    });
     registry.registerPath({
         method: 'post',
         path: '/pipelines',
@@ -93,4 +102,4 @@ export function registerPipelineRoutes() {
         responses: { 200: { description: 'SSE event stream of partial pipeline objects' }, 400: { description: 'Validation error' } },
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/pipeline-routes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Pipelines'];\nconst auth = [{ bearerAuth: [] }];\n\nexport function registerPipelineRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines',\n    summary: 'List pipelines',\n    description: 'List pipelines with pagination, filtering, and sorting.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Paginated list of pipelines' }, 401: { description: 'Unauthorized' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/find',\n    summary: 'Find a single pipeline',\n    description: 'Find a single pipeline matching the query filters.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline found' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/{id}',\n    summary: 'Get pipeline by ID',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline details' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/{id}/scorecard',\n    summary: 'Get a pipeline maturity scorecard',\n    description: 'Per-pipeline maturity scorecard blending compliance posture with DORA performance bands into a 0–100 score and letter grade. Requires the `advanced_reporting` feature.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Scorecard' }, 403: { description: 'Feature not enabled' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines',\n    summary: 'Create a pipeline',\n    description: 'Create a new pipeline configuration. Checks pipeline quota.',\n    tags,\n    security: auth,\n    responses: { 201: { description: 'Pipeline created' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/pipelines/{id}',\n    summary: 'Update a pipeline',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline updated' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/pipelines/{id}',\n    summary: 'Delete a pipeline',\n    description: 'Soft-delete a pipeline by setting isActive to false.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline deleted' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/providers',\n    summary: 'List AI providers',\n    description: 'List AI providers configured for pipeline generation.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of available AI providers with models' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines/generate',\n    summary: 'Generate pipeline via AI',\n    description: 'Generate a BuilderProps configuration from a natural language prompt. Returns the complete result when done.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Generated pipeline configuration' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines/generate/stream',\n    summary: 'Stream pipeline generation via AI',\n    description: 'Generate a BuilderProps configuration from a natural language prompt. Streams partial results as SSE events.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'SSE event stream of partial pipeline objects' }, 400: { description: 'Validation error' } },\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/pipeline-routes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Pipelines'];\nconst auth = [{ bearerAuth: [] }];\n\nexport function registerPipelineRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines',\n    summary: 'List pipelines',\n    description: 'List pipelines with pagination, filtering, and sorting.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Paginated list of pipelines' }, 401: { description: 'Unauthorized' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/find',\n    summary: 'Find a single pipeline',\n    description: 'Find a single pipeline matching the query filters.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline found' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/{id}',\n    summary: 'Get pipeline by ID',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline details' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/{id}/scorecard',\n    summary: 'Get a pipeline maturity scorecard',\n    description: 'Per-pipeline maturity scorecard blending compliance posture with DORA performance bands into a 0–100 score and letter grade. Requires the `advanced_reporting` feature.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Scorecard' }, 403: { description: 'Feature not enabled' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/scorecard',\n    summary: 'Org-wide scorecard roll-up (software-health leaderboard)',\n    description: 'Grades every pipeline in the organization and returns a ranked leaderboard plus aggregate stats (pipeline count, average score, grade distribution). Bounded per request. Requires the `advanced_reporting` feature.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Org-wide scorecard roll-up' }, 403: { description: 'Feature not enabled' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines',\n    summary: 'Create a pipeline',\n    description: 'Create a new pipeline configuration. Checks pipeline quota.',\n    tags,\n    security: auth,\n    responses: { 201: { description: 'Pipeline created' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/pipelines/{id}',\n    summary: 'Update a pipeline',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline updated' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/pipelines/{id}',\n    summary: 'Delete a pipeline',\n    description: 'Soft-delete a pipeline by setting isActive to false.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Pipeline deleted' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/pipelines/providers',\n    summary: 'List AI providers',\n    description: 'List AI providers configured for pipeline generation.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of available AI providers with models' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines/generate',\n    summary: 'Generate pipeline via AI',\n    description: 'Generate a BuilderProps configuration from a natural language prompt. Returns the complete result when done.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Generated pipeline configuration' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/pipelines/generate/stream',\n    summary: 'Stream pipeline generation via AI',\n    description: 'Generate a BuilderProps configuration from a natural language prompt. Streams partial results as SSE events.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'SSE event stream of partial pipeline objects' }, 400: { description: 'Validation error' } },\n  });\n}\n"]}

package/lib/openapi/routes/pipeline-template-routes.js

@@ -8,7 +8,7 @@ export function registerPipelineTemplateRoutes() {
         method: 'get',
         path: '/pipeline-templates',
         summary: 'List pipeline templates',
-        description: 'List golden-path pipeline templates (own-org + shared system-org catalog) with pagination and filtering.',
+        description: 'List golden-path pipeline templates with pagination and filtering. Visibility is a three-rung ladder: `private` (author only), `org` (everyone in the owning org), `public` (the org, its teams, and — for the system org — every org). Optional `visibility` query param narrows within what the caller can already see.',
         tags,
         security: auth,
         responses: { 200: { description: 'Paginated list of templates' }, 401: { description: 'Unauthorized' } },
@@ -34,26 +34,28 @@ export function registerPipelineTemplateRoutes() {
         method: 'post',
         path: '/pipeline-templates',
         summary: 'Create a pipeline template',
-        description: 'Author a golden-path template. Requires the `pipelines:write` permission.',
+        description: 'Author a golden-path template. Requires `templates:write`; `visibility: public` additionally requires `templates:publish` (a caller without it is clamped to `org`). Defaults to `private` — a personal draft only the author can see.',
         tags,
         security: auth,
-        responses: { 201: { description: 'Template created' }, 400: { description: 'Validation error' }, 403: { description: 'Forbidden' } },
+        responses: { 201: { description: 'Template created' }, 400: { description: 'Validation error' }, 403: { description: 'Forbidden' }, 409: { description: 'A template with that name already exists in the organization' } },
     });
     registry.registerPath({
         method: 'put',
         path: '/pipeline-templates/{id}',
         summary: 'Update a pipeline template',
+        description: 'Requires `templates:write`, plus `templates:publish` for a `public` template and authorship for a `private` one.',
         tags,
         security: auth,
-        responses: { 200: { description: 'Template updated' }, 404: { description: 'Not found' } },
+        responses: { 200: { description: 'Template updated' }, 403: { description: 'Forbidden' }, 404: { description: 'Not found' } },
     });
     registry.registerPath({
         method: 'delete',
         path: '/pipeline-templates/{id}',
         summary: 'Delete a pipeline template',
+        description: 'Same authority as update: `templates:write`, plus `templates:publish` for a `public` template and authorship for a `private` one.',
         tags,
         security: auth,
-        responses: { 200: { description: 'Template deleted' }, 404: { description: 'Not found' } },
+        responses: { 200: { description: 'Template deleted' }, 403: { description: 'Forbidden' }, 404: { description: 'Not found' } },
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/schema-registry.js

@@ -3,7 +3,7 @@
 import { z } from 'zod';
 import { registry } from './registry.js';
 import { AIGenerateBodySchema, PluginDeployGeneratedSchema, } from '../validation/ai-schemas.js';
-import { AccessModifierSchema, PaginationSchema, BaseFilterSchema, } from '../validation/common-schemas.js';
+import { VisibilitySchema, PaginationSchema, BaseFilterSchema, } from '../validation/common-schemas.js';
 import { MessageFilterSchema, MessageCreateSchema, MessageReplySchema, } from '../validation/message-schemas.js';
 import { PipelineFilterSchema, PipelineCreateSchema, PipelineUpdateSchema, } from '../validation/pipeline-schemas.js';
 import { PluginFilterSchema, PluginCreateSchema, PluginUpdateSchema, PluginUploadBodySchema, } from '../validation/plugin-schemas.js';
@@ -33,8 +33,8 @@ export const PaginatedResponseSchema = z.object({
 });
 export function registerSchemas() {
     // Common schemas
-    registry.register('AccessModifier', AccessModifierSchema.openapi({
-        description: 'Resource visibility: "public" (visible to all) or "private" (organization only)',
+    registry.register('Visibility', VisibilitySchema.openapi({
+        description: 'Sharing rung: "private" (author only), "org" (everyone in the owning organization), or "public" (the org, its teams, and — from the system org — every org)',
         example: 'private',
     }));
     registry.register('PaginationParams', PaginationSchema.openapi({
@@ -88,4 +88,4 @@ export function registerSchemas() {
     registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));
     registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-registry.js","sourceRoot":"","sources":["../../src/openapi/schema-registry.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from 'zod';\n\nimport { registry } from './registry.js';\nimport {\n  AIGenerateBodySchema,\n  PluginDeployGeneratedSchema,\n} from '../validation/ai-schemas.js';\nimport {\n  AccessModifierSchema,\n  PaginationSchema,\n  BaseFilterSchema,\n} from '../validation/common-schemas.js';\nimport {\n  MessageFilterSchema,\n  MessageCreateSchema,\n  MessageReplySchema,\n} from '../validation/message-schemas.js';\nimport {\n  PipelineFilterSchema,\n  PipelineCreateSchema,\n  PipelineUpdateSchema,\n} from '../validation/pipeline-schemas.js';\nimport {\n  PluginFilterSchema,\n  PluginCreateSchema,\n  PluginUpdateSchema,\n  PluginUploadBodySchema,\n} from '../validation/plugin-schemas.js';\n\n// Response schemas (exported for type usage)\nexport const SuccessResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.unknown().optional(),\n  message: z.string().optional(),\n});\n\nexport const ErrorResponseSchema = z.object({\n  success: z.literal(false),\n  statusCode: z.number(),\n  message: z.string(),\n  code: z.string().optional(),\n  details: z.unknown().optional(),\n});\n\nexport const PaginatedResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.array(z.unknown()),\n  count: z.number(),\n  limit: z.number(),\n  offset: z.number(),\n  total: z.number().optional(),\n  message: z.string().optional(),\n});\n\nexport function registerSchemas(): void {\n  // Common schemas\n  registry.register('AccessModifier', AccessModifierSchema.openapi({\n    description: 'Resource visibility: \"public\" (visible to all) or \"private\" (organization only)',\n    example: 'private',\n  }));\n\n  registry.register('PaginationParams', PaginationSchema.openapi({\n    description: 'Standard pagination and sorting parameters',\n  }));\n\n  registry.register('BaseFilter', BaseFilterSchema.openapi({\n    description: 'Common filter fields shared by all entity queries',\n  }));\n\n  // Pipeline schemas\n  registry.register('PipelineFilter', PipelineFilterSchema.openapi({\n    description: 'Query filters for listing pipelines',\n  }));\n\n  registry.register('PipelineCreate', PipelineCreateSchema.openapi({\n    description: 'Request body for creating a new pipeline',\n  }));\n\n  registry.register('PipelineUpdate', PipelineUpdateSchema.openapi({\n    description: 'Request body for updating an existing pipeline',\n  }));\n\n  // Plugin schemas\n  registry.register('PluginFilter', PluginFilterSchema.openapi({\n    description: 'Query filters for listing plugins',\n  }));\n\n  registry.register('PluginCreate', PluginCreateSchema.openapi({\n    description: 'Request body for creating a new plugin',\n  }));\n\n  registry.register('PluginUpdate', PluginUpdateSchema.openapi({\n    description: 'Request body for updating an existing plugin',\n  }));\n\n  registry.register('PluginUploadBody', PluginUploadBodySchema.openapi({\n    description: 'Metadata for plugin ZIP upload (multipart form-data)',\n  }));\n\n  // Message schemas\n  registry.register('MessageFilter', MessageFilterSchema.openapi({\n    description: 'Query filters for listing messages',\n  }));\n\n  registry.register('MessageCreate', MessageCreateSchema.openapi({\n    description: 'Request body for creating a new message or announcement',\n  }));\n\n  registry.register('MessageReply', MessageReplySchema.openapi({\n    description: 'Request body for replying to a message thread',\n  }));\n\n  // AI schemas\n  registry.register('AIGenerateBody', AIGenerateBodySchema.openapi({\n    description: 'Request body for AI-powered generation (pipeline or plugin)',\n  }));\n\n  registry.register('PluginDeployGenerated', PluginDeployGeneratedSchema.openapi({\n    description: 'Request body for deploying an AI-generated plugin',\n  }));\n\n  // Response schemas\n  registry.register('SuccessResponse', SuccessResponseSchema.openapi('SuccessResponse'));\n  registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));\n  registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-registry.js","sourceRoot":"","sources":["../../src/openapi/schema-registry.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from 'zod';\n\nimport { registry } from './registry.js';\nimport {\n  AIGenerateBodySchema,\n  PluginDeployGeneratedSchema,\n} from '../validation/ai-schemas.js';\nimport {\n  VisibilitySchema,\n  PaginationSchema,\n  BaseFilterSchema,\n} from '../validation/common-schemas.js';\nimport {\n  MessageFilterSchema,\n  MessageCreateSchema,\n  MessageReplySchema,\n} from '../validation/message-schemas.js';\nimport {\n  PipelineFilterSchema,\n  PipelineCreateSchema,\n  PipelineUpdateSchema,\n} from '../validation/pipeline-schemas.js';\nimport {\n  PluginFilterSchema,\n  PluginCreateSchema,\n  PluginUpdateSchema,\n  PluginUploadBodySchema,\n} from '../validation/plugin-schemas.js';\n\n// Response schemas (exported for type usage)\nexport const SuccessResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.unknown().optional(),\n  message: z.string().optional(),\n});\n\nexport const ErrorResponseSchema = z.object({\n  success: z.literal(false),\n  statusCode: z.number(),\n  message: z.string(),\n  code: z.string().optional(),\n  details: z.unknown().optional(),\n});\n\nexport const PaginatedResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.array(z.unknown()),\n  count: z.number(),\n  limit: z.number(),\n  offset: z.number(),\n  total: z.number().optional(),\n  message: z.string().optional(),\n});\n\nexport function registerSchemas(): void {\n  // Common schemas\n  registry.register('Visibility', VisibilitySchema.openapi({\n    description: 'Sharing rung: \"private\" (author only), \"org\" (everyone in the owning organization), or \"public\" (the org, its teams, and — from the system org — every org)',\n    example: 'private',\n  }));\n\n  registry.register('PaginationParams', PaginationSchema.openapi({\n    description: 'Standard pagination and sorting parameters',\n  }));\n\n  registry.register('BaseFilter', BaseFilterSchema.openapi({\n    description: 'Common filter fields shared by all entity queries',\n  }));\n\n  // Pipeline schemas\n  registry.register('PipelineFilter', PipelineFilterSchema.openapi({\n    description: 'Query filters for listing pipelines',\n  }));\n\n  registry.register('PipelineCreate', PipelineCreateSchema.openapi({\n    description: 'Request body for creating a new pipeline',\n  }));\n\n  registry.register('PipelineUpdate', PipelineUpdateSchema.openapi({\n    description: 'Request body for updating an existing pipeline',\n  }));\n\n  // Plugin schemas\n  registry.register('PluginFilter', PluginFilterSchema.openapi({\n    description: 'Query filters for listing plugins',\n  }));\n\n  registry.register('PluginCreate', PluginCreateSchema.openapi({\n    description: 'Request body for creating a new plugin',\n  }));\n\n  registry.register('PluginUpdate', PluginUpdateSchema.openapi({\n    description: 'Request body for updating an existing plugin',\n  }));\n\n  registry.register('PluginUploadBody', PluginUploadBodySchema.openapi({\n    description: 'Metadata for plugin ZIP upload (multipart form-data)',\n  }));\n\n  // Message schemas\n  registry.register('MessageFilter', MessageFilterSchema.openapi({\n    description: 'Query filters for listing messages',\n  }));\n\n  registry.register('MessageCreate', MessageCreateSchema.openapi({\n    description: 'Request body for creating a new message or announcement',\n  }));\n\n  registry.register('MessageReply', MessageReplySchema.openapi({\n    description: 'Request body for replying to a message thread',\n  }));\n\n  // AI schemas\n  registry.register('AIGenerateBody', AIGenerateBodySchema.openapi({\n    description: 'Request body for AI-powered generation (pipeline or plugin)',\n  }));\n\n  registry.register('PluginDeployGenerated', PluginDeployGeneratedSchema.openapi({\n    description: 'Request body for deploying an AI-generated plugin',\n  }));\n\n  // Response schemas\n  registry.register('SuccessResponse', SuccessResponseSchema.openapi('SuccessResponse'));\n  registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));\n  registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));\n}\n"]}

package/lib/services/circuit-breaker.d.ts

@@ -0,0 +1,45 @@
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export interface CircuitBreakerConfig {
+    /** Consecutive failures that trip the breaker from closed → open. */
+    failureThreshold: number;
+    /** How long to stay open before allowing a half-open probe (ms). */
+    cooldownMs: number;
+    /** Master switch — when false, allowRequest() is always true and no state moves. */
+    enabled: boolean;
+}
+export declare const DEFAULT_BREAKER_CONFIG: CircuitBreakerConfig;
+/**
+ * A single target's breaker. Not concurrency-locked (JS is single-threaded per
+ * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst
+ * during cooldown doesn't stampede the recovering downstream.
+ */
+export declare class CircuitBreaker {
+    private readonly key;
+    private readonly config;
+    private state;
+    private consecutiveFailures;
+    private openedAt;
+    private probeInFlight;
+    constructor(key: string, config?: CircuitBreakerConfig);
+    getState(): CircuitState;
+    /**
+     * Whether a request may proceed. Transitions open→half-open once the cooldown
+     * elapses and lets exactly ONE probe through. Returns false when open (or a
+     * probe is already in flight) — the caller must fast-fail without any network.
+     */
+    allowRequest(): boolean;
+    /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */
+    recordSuccess(): void;
+    /** A logical request failed (connection error, timeout, or 5xx response). */
+    recordFailure(): void;
+    private open;
+}
+/** Get (or lazily create) the shared breaker for a `host:port` target. */
+export declare function getCircuitBreaker(key: string): CircuitBreaker;
+/** Test helper: clear all breaker state so suites don't leak across each other. */
+export declare function resetCircuitBreakers(): void;
+/** Thrown by the client when a request is fast-failed because the breaker is open. */
+export declare class CircuitOpenError extends Error {
+    readonly code = "CIRCUIT_OPEN";
+    constructor(target: string);
+}

package/lib/services/circuit-breaker.js

@@ -0,0 +1,138 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Per-target circuit breaker for service-to-service calls.
+ *
+ * The shared {@link InternalHttpClient} already has timeouts, a bounded socket
+ * pool, and bounded retry-with-jitter — but no load-shedding. Under a sustained
+ * downstream brownout every caller keeps paying `timeout × (maxRetries+1)` per
+ * request, saturating the socket pool and turning one slow dependency into a
+ * fleet-wide latency cascade (the classic retry storm). Worse for fail-CLOSED
+ * dependencies (compliance): a brownout there blocks plugin/pipeline creation
+ * with full retry latency on every request.
+ *
+ * This breaker short-circuits that: after `failureThreshold` consecutive
+ * failures to a target it OPENS and fast-fails (no network, no retries) for
+ * `cooldownMs`, then allows a single half-open probe. A fail-closed caller still
+ * fails closed — just immediately, instead of after the full retry budget; a
+ * fail-open caller (createSafeClient) gets its `null` immediately.
+ *
+ * State is keyed by `host:port` in a process-level registry so it is shared even
+ * when callers mint a fresh client per request — one bad target trips once, not
+ * once-per-client. Disable entirely with `S2S_BREAKER_ENABLED=false`.
+ */
+import { envInt, envBool } from '../utils/env.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('circuit-breaker');
+export const DEFAULT_BREAKER_CONFIG = {
+    failureThreshold: envInt('S2S_BREAKER_THRESHOLD', 5, { min: 1 }),
+    cooldownMs: envInt('S2S_BREAKER_COOLDOWN_MS', 10000, { min: 1 }),
+    enabled: envBool('S2S_BREAKER_ENABLED', true),
+};
+/**
+ * A single target's breaker. Not concurrency-locked (JS is single-threaded per
+ * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst
+ * during cooldown doesn't stampede the recovering downstream.
+ */
+export class CircuitBreaker {
+    key;
+    config;
+    state = 'closed';
+    consecutiveFailures = 0;
+    openedAt = 0;
+    probeInFlight = false;
+    constructor(key, config = DEFAULT_BREAKER_CONFIG) {
+        this.key = key;
+        this.config = config;
+    }
+    getState() {
+        return this.state;
+    }
+    /**
+     * Whether a request may proceed. Transitions open→half-open once the cooldown
+     * elapses and lets exactly ONE probe through. Returns false when open (or a
+     * probe is already in flight) — the caller must fast-fail without any network.
+     */
+    allowRequest() {
+        if (!this.config.enabled)
+            return true;
+        if (this.state === 'closed')
+            return true;
+        if (this.state === 'open') {
+            if (Date.now() - this.openedAt >= this.config.cooldownMs) {
+                this.state = 'half-open';
+                this.probeInFlight = true;
+                return true;
+            }
+            return false;
+        }
+        // half-open: allow only a single probe at a time.
+        if (this.probeInFlight)
+            return false;
+        this.probeInFlight = true;
+        return true;
+    }
+    /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */
+    recordSuccess() {
+        if (!this.config.enabled)
+            return;
+        this.consecutiveFailures = 0;
+        this.probeInFlight = false;
+        if (this.state !== 'closed') {
+            logger.info('circuit closed (downstream recovered)', { target: this.key });
+            this.state = 'closed';
+        }
+    }
+    /** A logical request failed (connection error, timeout, or 5xx response). */
+    recordFailure() {
+        if (!this.config.enabled)
+            return;
+        this.probeInFlight = false;
+        this.consecutiveFailures++;
+        // A failed half-open probe means the downstream is still bad — re-open.
+        if (this.state === 'half-open') {
+            this.open();
+            return;
+        }
+        if (this.state === 'closed' && this.consecutiveFailures >= this.config.failureThreshold) {
+            this.open();
+        }
+    }
+    open() {
+        const wasOpen = this.state === 'open';
+        this.state = 'open';
+        this.openedAt = Date.now();
+        if (!wasOpen) {
+            logger.warn('circuit opened — shedding load to target', {
+                target: this.key,
+                consecutiveFailures: this.consecutiveFailures,
+                cooldownMs: this.config.cooldownMs,
+            });
+            emitCounter('s2s_circuit_opened_total', { target: this.key });
+        }
+    }
+}
+const registry = new Map();
+/** Get (or lazily create) the shared breaker for a `host:port` target. */
+export function getCircuitBreaker(key) {
+    let breaker = registry.get(key);
+    if (!breaker) {
+        breaker = new CircuitBreaker(key);
+        registry.set(key, breaker);
+    }
+    return breaker;
+}
+/** Test helper: clear all breaker state so suites don't leak across each other. */
+export function resetCircuitBreakers() {
+    registry.clear();
+}
+/** Thrown by the client when a request is fast-failed because the breaker is open. */
+export class CircuitOpenError extends Error {
+    code = 'CIRCUIT_OPEN';
+    constructor(target) {
+        super(`Circuit open for ${target} — fast-failing to shed load`);
+        this.name = 'CircuitOpenError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"circuit-breaker.js","sourceRoot":"","sources":["../../src/services/circuit-breaker.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-target circuit breaker for service-to-service calls.\n *\n * The shared {@link InternalHttpClient} already has timeouts, a bounded socket\n * pool, and bounded retry-with-jitter — but no load-shedding. Under a sustained\n * downstream brownout every caller keeps paying `timeout × (maxRetries+1)` per\n * request, saturating the socket pool and turning one slow dependency into a\n * fleet-wide latency cascade (the classic retry storm). Worse for fail-CLOSED\n * dependencies (compliance): a brownout there blocks plugin/pipeline creation\n * with full retry latency on every request.\n *\n * This breaker short-circuits that: after `failureThreshold` consecutive\n * failures to a target it OPENS and fast-fails (no network, no retries) for\n * `cooldownMs`, then allows a single half-open probe. A fail-closed caller still\n * fails closed — just immediately, instead of after the full retry budget; a\n * fail-open caller (createSafeClient) gets its `null` immediately.\n *\n * State is keyed by `host:port` in a process-level registry so it is shared even\n * when callers mint a fresh client per request — one bad target trips once, not\n * once-per-client. Disable entirely with `S2S_BREAKER_ENABLED=false`.\n */\n\nimport { envInt, envBool } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('circuit-breaker');\n\nexport type CircuitState = 'closed' | 'open' | 'half-open';\n\nexport interface CircuitBreakerConfig {\n  /** Consecutive failures that trip the breaker from closed → open. */\n  failureThreshold: number;\n  /** How long to stay open before allowing a half-open probe (ms). */\n  cooldownMs: number;\n  /** Master switch — when false, allowRequest() is always true and no state moves. */\n  enabled: boolean;\n}\n\nexport const DEFAULT_BREAKER_CONFIG: CircuitBreakerConfig = {\n  failureThreshold: envInt('S2S_BREAKER_THRESHOLD', 5, { min: 1 }),\n  cooldownMs: envInt('S2S_BREAKER_COOLDOWN_MS', 10000, { min: 1 }),\n  enabled: envBool('S2S_BREAKER_ENABLED', true),\n};\n\n/**\n * A single target's breaker. Not concurrency-locked (JS is single-threaded per\n * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst\n * during cooldown doesn't stampede the recovering downstream.\n */\nexport class CircuitBreaker {\n  private state: CircuitState = 'closed';\n  private consecutiveFailures = 0;\n  private openedAt = 0;\n  private probeInFlight = false;\n\n  constructor(\n    private readonly key: string,\n    private readonly config: CircuitBreakerConfig = DEFAULT_BREAKER_CONFIG,\n  ) {}\n\n  getState(): CircuitState {\n    return this.state;\n  }\n\n  /**\n   * Whether a request may proceed. Transitions open→half-open once the cooldown\n   * elapses and lets exactly ONE probe through. Returns false when open (or a\n   * probe is already in flight) — the caller must fast-fail without any network.\n   */\n  allowRequest(): boolean {\n    if (!this.config.enabled) return true;\n    if (this.state === 'closed') return true;\n    if (this.state === 'open') {\n      if (Date.now() - this.openedAt >= this.config.cooldownMs) {\n        this.state = 'half-open';\n        this.probeInFlight = true;\n        return true;\n      }\n      return false;\n    }\n    // half-open: allow only a single probe at a time.\n    if (this.probeInFlight) return false;\n    this.probeInFlight = true;\n    return true;\n  }\n\n  /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */\n  recordSuccess(): void {\n    if (!this.config.enabled) return;\n    this.consecutiveFailures = 0;\n    this.probeInFlight = false;\n    if (this.state !== 'closed') {\n      logger.info('circuit closed (downstream recovered)', { target: this.key });\n      this.state = 'closed';\n    }\n  }\n\n  /** A logical request failed (connection error, timeout, or 5xx response). */\n  recordFailure(): void {\n    if (!this.config.enabled) return;\n    this.probeInFlight = false;\n    this.consecutiveFailures++;\n    // A failed half-open probe means the downstream is still bad — re-open.\n    if (this.state === 'half-open') {\n      this.open();\n      return;\n    }\n    if (this.state === 'closed' && this.consecutiveFailures >= this.config.failureThreshold) {\n      this.open();\n    }\n  }\n\n  private open(): void {\n    const wasOpen = this.state === 'open';\n    this.state = 'open';\n    this.openedAt = Date.now();\n    if (!wasOpen) {\n      logger.warn('circuit opened — shedding load to target', {\n        target: this.key,\n        consecutiveFailures: this.consecutiveFailures,\n        cooldownMs: this.config.cooldownMs,\n      });\n      emitCounter('s2s_circuit_opened_total', { target: this.key });\n    }\n  }\n}\n\nconst registry = new Map<string, CircuitBreaker>();\n\n/** Get (or lazily create) the shared breaker for a `host:port` target. */\nexport function getCircuitBreaker(key: string): CircuitBreaker {\n  let breaker = registry.get(key);\n  if (!breaker) {\n    breaker = new CircuitBreaker(key);\n    registry.set(key, breaker);\n  }\n  return breaker;\n}\n\n/** Test helper: clear all breaker state so suites don't leak across each other. */\nexport function resetCircuitBreakers(): void {\n  registry.clear();\n}\n\n/** Thrown by the client when a request is fast-failed because the breaker is open. */\nexport class CircuitOpenError extends Error {\n  readonly code = 'CIRCUIT_OPEN';\n  constructor(target: string) {\n    super(`Circuit open for ${target} — fast-failing to shed load`);\n    this.name = 'CircuitOpenError';\n  }\n}\n"]}