@pipeline-builder/api-core 4.1.6 → 4.1.8

package/README.md

@@ -36,6 +36,8 @@ Provides the cross-cutting primitives every backend service depends on: JWT auth
 | --- | --- |
 | `getParam`, `getRequiredParam`, `getParams`, `getOrgId`, `getAuthHeader` | Request parameter/header extraction |
 | `parseQueryBoolean`, `parseQueryInt`, `parseQueryString` | Query-string coercion |
+| `parsePage` | **The** pagination primitive — parses and clamps `?limit=&offset=` against a per-route `{ def, max }` (and an optional `maxOffset`). Use it instead of a hand-rolled `Math.min(Math.max(...))`; route defaults stay per-route but are declared, not re-derived |
+| `envInt`, `envBool`, `envStr` | **The** env readers. Strict (a non-integer `envInt` falls back to the default rather than silently truncating), and every variable read through them must appear in `docs/environment-variables.md` — enforced by `test/env-documented.test.ts` |
 | `getIdentity`, `validateIdentity` | Parsed JWT identity (`RequestIdentity`) helpers |
 
 ### HTTP client & services (`./services`)
@@ -45,6 +47,12 @@ Provides the cross-cutting primitives every backend service depends on: JWT auth
 | `createComplianceClient` / `ComplianceClient` | Typed compliance-service client built on the safe client |
 | `QuotaService`, `createQuotaService`, `QuotaType`, `QuotaCheckResult`, `QuotaTier`, `QUOTA_TIERS`, `getTierLimits` | Quota enforcement client and tier presets |
 | `CacheService`, `createCacheService` | In-memory LRU TTL cache with cross-replica invalidation over Redis pub/sub |
+| `safeFetch`, `resolveSafeTarget`, `assertSafeUrl`, `isPrivateAddress` | SSRF guards for user/tenant-supplied URLs. **`safeFetch` is the one to use for an outbound request**: it resolves the host, PINS the vetted IP into the socket (no DNS-rebinding window between check and connect), refuses redirects, and caps body size and wall-clock time. `assertSafeUrl` is VALIDATION ONLY — for rejecting a URL at create/update time; never pair it with a `fetch` |
+| `createWebhookChannel`, `createEmailChannel`, `createChannelRegistry`, `NotificationChannel`, `NotificationMessage`, `ChannelTarget`, `DeliveryResult` | Shared notification-channel contract plus the webhook (SSRF-safe, HMAC-signing) and email transports. Services supply only their own `in-app` transport |
+| `wireServiceSecurity` | One call for every stateless service's boot security: the `authz.denied` audit sink, the token-revocation reader (overridable), and the access-key-exchange service name |
+| `createRemoteAuditAccessor` | Returns both audit shapes a service needs — `getAuditClient` (for `wireServiceSecurity`) and `emit` (the terse per-service emitter) |
+| `getRetryDecision`, `getErrorRetryDecision`, `RetryConfig` | The single retry/backoff decision function (Retry-After aware, jittered) and the single `RetryConfig`. pipeline-data's `ConnectionRetryStrategy` is built on it |
+| `createOrgIdCaster` | Builds the Mongo org-id cast (24-hex → ObjectId, anything else through) from a supplied `Types.ObjectId`, so platform and quota share one implementation without api-core depending on mongoose |
 | `entityEvents` | Process-local domain event pub/sub for entity changes |
 
 ### Logging, validation & OpenAPI

package/lib/helpers/org-hierarchy.d.ts

@@ -25,6 +25,25 @@ export type GetParentOrgId = (orgId: string) => Promise<string | undefined>;
 export type GetChildOrgIds = (frontier: string[]) => Promise<string[]>;
 /** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */
 export declare function toOrgIdString(v: unknown): string | undefined;
+/**
+ * Build the org-id cast the Mongo-backed services use on every `_id` lookup.
+ *
+ * Platform writes ObjectId `_id`s into the shared `organizations` collection,
+ * while the well-known `'system'` org (and `parentOrgId`, still a String column)
+ * are plain strings — so a 24-hex id arriving from a route param / JWT claim /
+ * cross-service payload must be cast or `findById('<24hex>')` never matches.
+ *
+ * Platform and quota each had their OWN `toOrgId` with a different signature
+ * (`string | string[]` vs `string`), which is exactly the drift this removes:
+ * the logic and the signature live here once, and each service supplies only
+ * its mongoose `Types.ObjectId` constructor. api-core cannot import mongoose
+ * itself (it is not — and should not become — an api-core dependency), so the
+ * constructor is injected rather than imported.
+ *
+ * @example
+ * export const toOrgId = createOrgIdCaster(mongoose.Types.ObjectId);
+ */
+export declare function createOrgIdCaster<T>(ObjectIdCtor: new (hex: string) => T): (id: string | string[]) => string | T;
 export interface OrgLineage {
     /** The org's direct parent id, or `undefined` when it's a root org. */
     parentOrgId?: string;

package/lib/helpers/org-hierarchy.js

@@ -28,6 +28,34 @@ export function toOrgIdString(v) {
     const s = String(v);
     return s && s !== 'null' && s !== 'undefined' ? s : undefined;
 }
+/** True when `id` is a 24-character hex string — i.e. castable to an ObjectId. */
+function isObjectIdHex(id) {
+    return id.length === 24 && /^[0-9a-fA-F]{24}$/.test(id);
+}
+/**
+ * Build the org-id cast the Mongo-backed services use on every `_id` lookup.
+ *
+ * Platform writes ObjectId `_id`s into the shared `organizations` collection,
+ * while the well-known `'system'` org (and `parentOrgId`, still a String column)
+ * are plain strings — so a 24-hex id arriving from a route param / JWT claim /
+ * cross-service payload must be cast or `findById('<24hex>')` never matches.
+ *
+ * Platform and quota each had their OWN `toOrgId` with a different signature
+ * (`string | string[]` vs `string`), which is exactly the drift this removes:
+ * the logic and the signature live here once, and each service supplies only
+ * its mongoose `Types.ObjectId` constructor. api-core cannot import mongoose
+ * itself (it is not — and should not become — an api-core dependency), so the
+ * constructor is injected rather than imported.
+ *
+ * @example
+ * export const toOrgId = createOrgIdCaster(mongoose.Types.ObjectId);
+ */
+export function createOrgIdCaster(ObjectIdCtor) {
+    return (id) => {
+        const idStr = Array.isArray(id) ? id[0] : id;
+        return isObjectIdHex(idStr) ? new ObjectIdCtor(idStr) : idStr;
+    };
+}
 /**
  * Walk `parentOrgId` from `orgId` up to the root. Returns the direct parent (if
  * any) and the root org id (the input itself when the org has no parent). On a
@@ -107,4 +135,4 @@ export async function expandOrgScopeWith(orgId, getChildren) {
     }
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;GAkBG;AAEH,2EAA2E;AAC3E,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAQhC,oFAAoF;AACpF,MAAM,UAAU,aAAa,CAAC,CAAU;IACtC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACpD,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,CAAC,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAChE,CAAC;AASD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,KAAa,EAAE,SAAyB;IAClF,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,IAAI,WAA+B,CAAC;IAEpC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM;YAAE,MAAM,CAAC,wBAAwB;QAC5C,0EAA0E;QAC1E,4CAA4C;QAC5C,IAAI,KAAK,KAAK,CAAC,IAAI,MAAM,KAAK,KAAK;YAAE,WAAW,GAAG,MAAM,CAAC;QAC1D,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,MAAM,CAAC,sCAAsC;QACnE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjB,SAAS,GAAG,MAAM,CAAC;IACrB,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;AACvE,CAAC;AAED,qEAAqE;AACrE,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,KAAa,EAAE,SAAyB;IACjF,OAAO,CAAC,MAAM,qBAAqB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,aAAqB,EACrB,cAAsB,EACtB,SAAyB;IAEzB,IAAI,aAAa,KAAK,cAAc;QAAE,OAAO,KAAK,CAAC;IAEnD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,cAAc,CAAC,CAAC,CAAC;IAC/C,IAAI,SAAS,GAAG,cAAc,CAAC;IAE/B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,aAAa,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC,CAAC,kCAAkC;QAC7D,IAAI,MAAM,KAAK,aAAa;YAAE,OAAO,IAAI,CAAC;QAC1C,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC,CAAC,QAAQ;QAC5C,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjB,SAAS,GAAG,MAAM,CAAC;IACrB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,KAAa,EAAE,WAA2B;IACjF,MAAM,MAAM,GAAa,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,IAAI,QAAQ,GAAa,CAAC,KAAK,CAAC,CAAC;IAEjC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,aAAa,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QAC1E,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC7C,MAAM,IAAI,GAAa,EAAE,CAAC;QAC1B,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC3B,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBAAE,SAAS;YAClC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAChB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChB,CAAC;QACD,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy traversal (org-team-hierarchy proposal).\n *\n * A \"team\" is an organization whose `parentOrgId` points at another org; a root\n * org has `parentOrgId = null`. These helpers walk that single self-referential\n * column, but hold **no database dependency** of their own: each takes a query\n * callback so every service (platform, quota, …) can share the cycle-safe,\n * depth-capped traversal logic while reading its own Mongoose model with its own\n * `_id` casting rules.\n *\n *   - {@link resolveOrgLineageWith} — UP: direct parent + root of the chain.\n *   - {@link resolveRootOrgIdWith}   — UP: just the root id.\n *   - {@link isAncestorOrgWith}      — UP: is A an ancestor of B?\n *   - {@link expandOrgScopeWith}     — DOWN: self + all descendant org ids.\n *\n * Every org is flat today (`parentOrgId` null on all rows), so lineage resolves\n * to `{ rootOrgId: self }` and scope to `[self]` — i.e. these are no-ops until\n * orgs get parents.\n */\n\n/** Hard ceiling on ancestry/descendant traversal — cycle + abuse guard. */\nexport const MAX_ORG_DEPTH = 16;\n\n/** Fetch an org's direct `parentOrgId`, or undefined for a root/missing org. */\nexport type GetParentOrgId = (orgId: string) => Promise<string | undefined>;\n\n/** Fetch the direct child org ids of every org in `frontier` (one round of BFS). */\nexport type GetChildOrgIds = (frontier: string[]) => Promise<string[]>;\n\n/** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */\nexport function toOrgIdString(v: unknown): string | undefined {\n  if (v === null || v === undefined) return undefined;\n  const s = String(v);\n  return s && s !== 'null' && s !== 'undefined' ? s : undefined;\n}\n\nexport interface OrgLineage {\n  /** The org's direct parent id, or `undefined` when it's a root org. */\n  parentOrgId?: string;\n  /** Top of the ancestry chain. Equals the input `orgId` for a root org. */\n  rootOrgId: string;\n}\n\n/**\n * Walk `parentOrgId` from `orgId` up to the root. Returns the direct parent (if\n * any) and the root org id (the input itself when the org has no parent). On a\n * detected cycle, a missing org, or the depth cap, traversal stops and the last\n * reached id is treated as the root.\n */\nexport async function resolveOrgLineageWith(orgId: string, getParent: GetParentOrgId): Promise<OrgLineage> {\n  const seen = new Set<string>([orgId]);\n  let currentId = orgId;\n  let parentOrgId: string | undefined;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) break; // currentId is the root\n    // Record the direct parent only when it isn't a self-loop, so a malformed\n    // A→A org isn't reported as its own parent.\n    if (depth === 0 && parent !== orgId) parentOrgId = parent;\n    if (seen.has(parent)) break; // cycle — treat currentId as the root\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return { rootOrgId: currentId, ...(parentOrgId && { parentOrgId }) };\n}\n\n/** Walk `parentOrgId` up to the root and return just the root id. */\nexport async function resolveRootOrgIdWith(orgId: string, getParent: GetParentOrgId): Promise<string> {\n  return (await resolveOrgLineageWith(orgId, getParent)).rootOrgId;\n}\n\n/**\n * True when `ancestorOrgId` is an ancestor of `candidateOrgId` — i.e.\n * `candidateOrgId` lives somewhere in the subtree rooted at `ancestorOrgId`.\n * Walks `candidateOrgId`'s parent chain upward, depth-capped and cycle-safe.\n * Returns `false` when the two are equal (an org is not its own ancestor) or\n * unrelated.\n */\nexport async function isAncestorOrgWith(\n  ancestorOrgId: string,\n  candidateOrgId: string,\n  getParent: GetParentOrgId,\n): Promise<boolean> {\n  if (ancestorOrgId === candidateOrgId) return false;\n\n  const seen = new Set<string>([candidateOrgId]);\n  let currentId = candidateOrgId;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) return false; // reached a root without matching\n    if (parent === ancestorOrgId) return true;\n    if (seen.has(parent)) return false; // cycle\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return false;\n}\n\n/**\n * Expand `orgId` to itself plus every descendant org id (breadth-first over\n * `parentOrgId`). This is the scope a parent org \"sees\" for visibility and\n * analytics rollups: `[self, ...descendants]`. Returns `[orgId]` when the org\n * has no children. Cycle-safe and depth-capped.\n */\nexport async function expandOrgScopeWith(orgId: string, getChildren: GetChildOrgIds): Promise<string[]> {\n  const result: string[] = [orgId];\n  const seen = new Set<string>([orgId]);\n  let frontier: string[] = [orgId];\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH && frontier.length > 0; depth++) {\n    const children = await getChildren(frontier);\n    const next: string[] = [];\n    for (const raw of children) {\n      const id = toOrgIdString(raw);\n      if (!id || seen.has(id)) continue;\n      seen.add(id);\n      result.push(id);\n      next.push(id);\n    }\n    frontier = next;\n  }\n\n  return result;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy traversal (org-team-hierarchy proposal).\n *\n * A \"team\" is an organization whose `parentOrgId` points at another org; a root\n * org has `parentOrgId = null`. These helpers walk that single self-referential\n * column, but hold **no database dependency** of their own: each takes a query\n * callback so every service (platform, quota, …) can share the cycle-safe,\n * depth-capped traversal logic while reading its own Mongoose model with its own\n * `_id` casting rules.\n *\n *   - {@link resolveOrgLineageWith} — UP: direct parent + root of the chain.\n *   - {@link resolveRootOrgIdWith}   — UP: just the root id.\n *   - {@link isAncestorOrgWith}      — UP: is A an ancestor of B?\n *   - {@link expandOrgScopeWith}     — DOWN: self + all descendant org ids.\n *\n * Every org is flat today (`parentOrgId` null on all rows), so lineage resolves\n * to `{ rootOrgId: self }` and scope to `[self]` — i.e. these are no-ops until\n * orgs get parents.\n */\n\n/** Hard ceiling on ancestry/descendant traversal — cycle + abuse guard. */\nexport const MAX_ORG_DEPTH = 16;\n\n/** Fetch an org's direct `parentOrgId`, or undefined for a root/missing org. */\nexport type GetParentOrgId = (orgId: string) => Promise<string | undefined>;\n\n/** Fetch the direct child org ids of every org in `frontier` (one round of BFS). */\nexport type GetChildOrgIds = (frontier: string[]) => Promise<string[]>;\n\n/** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */\nexport function toOrgIdString(v: unknown): string | undefined {\n  if (v === null || v === undefined) return undefined;\n  const s = String(v);\n  return s && s !== 'null' && s !== 'undefined' ? s : undefined;\n}\n\n/** True when `id` is a 24-character hex string — i.e. castable to an ObjectId. */\nfunction isObjectIdHex(id: string): boolean {\n  return id.length === 24 && /^[0-9a-fA-F]{24}$/.test(id);\n}\n\n/**\n * Build the org-id cast the Mongo-backed services use on every `_id` lookup.\n *\n * Platform writes ObjectId `_id`s into the shared `organizations` collection,\n * while the well-known `'system'` org (and `parentOrgId`, still a String column)\n * are plain strings — so a 24-hex id arriving from a route param / JWT claim /\n * cross-service payload must be cast or `findById('<24hex>')` never matches.\n *\n * Platform and quota each had their OWN `toOrgId` with a different signature\n * (`string | string[]` vs `string`), which is exactly the drift this removes:\n * the logic and the signature live here once, and each service supplies only\n * its mongoose `Types.ObjectId` constructor. api-core cannot import mongoose\n * itself (it is not — and should not become — an api-core dependency), so the\n * constructor is injected rather than imported.\n *\n * @example\n * export const toOrgId = createOrgIdCaster(mongoose.Types.ObjectId);\n */\nexport function createOrgIdCaster<T>(\n  ObjectIdCtor: new (hex: string) => T,\n): (id: string | string[]) => string | T {\n  return (id) => {\n    const idStr = Array.isArray(id) ? id[0] : id;\n    return isObjectIdHex(idStr) ? new ObjectIdCtor(idStr) : idStr;\n  };\n}\n\nexport interface OrgLineage {\n  /** The org's direct parent id, or `undefined` when it's a root org. */\n  parentOrgId?: string;\n  /** Top of the ancestry chain. Equals the input `orgId` for a root org. */\n  rootOrgId: string;\n}\n\n/**\n * Walk `parentOrgId` from `orgId` up to the root. Returns the direct parent (if\n * any) and the root org id (the input itself when the org has no parent). On a\n * detected cycle, a missing org, or the depth cap, traversal stops and the last\n * reached id is treated as the root.\n */\nexport async function resolveOrgLineageWith(orgId: string, getParent: GetParentOrgId): Promise<OrgLineage> {\n  const seen = new Set<string>([orgId]);\n  let currentId = orgId;\n  let parentOrgId: string | undefined;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) break; // currentId is the root\n    // Record the direct parent only when it isn't a self-loop, so a malformed\n    // A→A org isn't reported as its own parent.\n    if (depth === 0 && parent !== orgId) parentOrgId = parent;\n    if (seen.has(parent)) break; // cycle — treat currentId as the root\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return { rootOrgId: currentId, ...(parentOrgId && { parentOrgId }) };\n}\n\n/** Walk `parentOrgId` up to the root and return just the root id. */\nexport async function resolveRootOrgIdWith(orgId: string, getParent: GetParentOrgId): Promise<string> {\n  return (await resolveOrgLineageWith(orgId, getParent)).rootOrgId;\n}\n\n/**\n * True when `ancestorOrgId` is an ancestor of `candidateOrgId` — i.e.\n * `candidateOrgId` lives somewhere in the subtree rooted at `ancestorOrgId`.\n * Walks `candidateOrgId`'s parent chain upward, depth-capped and cycle-safe.\n * Returns `false` when the two are equal (an org is not its own ancestor) or\n * unrelated.\n */\nexport async function isAncestorOrgWith(\n  ancestorOrgId: string,\n  candidateOrgId: string,\n  getParent: GetParentOrgId,\n): Promise<boolean> {\n  if (ancestorOrgId === candidateOrgId) return false;\n\n  const seen = new Set<string>([candidateOrgId]);\n  let currentId = candidateOrgId;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) return false; // reached a root without matching\n    if (parent === ancestorOrgId) return true;\n    if (seen.has(parent)) return false; // cycle\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return false;\n}\n\n/**\n * Expand `orgId` to itself plus every descendant org id (breadth-first over\n * `parentOrgId`). This is the scope a parent org \"sees\" for visibility and\n * analytics rollups: `[self, ...descendants]`. Returns `[orgId]` when the org\n * has no children. Cycle-safe and depth-capped.\n */\nexport async function expandOrgScopeWith(orgId: string, getChildren: GetChildOrgIds): Promise<string[]> {\n  const result: string[] = [orgId];\n  const seen = new Set<string>([orgId]);\n  let frontier: string[] = [orgId];\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH && frontier.length > 0; depth++) {\n    const children = await getChildren(frontier);\n    const next: string[] = [];\n    for (const raw of children) {\n      const id = toOrgIdString(raw);\n      if (!id || seen.has(id)) continue;\n      seen.add(id);\n      result.push(id);\n      next.push(id);\n    }\n    frontier = next;\n  }\n\n  return result;\n}\n"]}

package/lib/index.d.ts

@@ -22,6 +22,7 @@
  * - getParam, getOrgId — request parameter extraction
  * - parseQueryInt, parseQueryString — query string parsing
  * - getIdentity — identity extraction from requests
+ * - actorId — the audit actor for a route context (one `system` sentinel)
  * - errorMessage — safe error-to-string conversion
  *
  * **Constants**
@@ -33,6 +34,7 @@
  * - CacheService — in-memory TTL cache
  * - ComplianceClient — compliance service client
  * - EntityEventEmitter — domain event pub/sub
+ * - retryForever — capped-backoff wait for a dependency that must come up
  *
  * **Errors**
  * - AppError, NotFoundError, ForbiddenError — typed HTTP error classes
@@ -46,6 +48,30 @@
  * **OpenAPI**
  * - Schema registry and spec generation
  */
+/**
+ * PUBLIC SURFACE POLICY
+ *
+ * The root re-exports the ten sub-barrels, and each SUB-BARREL is the allow-list
+ * for its own area — that is where a module is either `export *`'d or narrowed
+ * to the names services may use. Internals are excluded there rather than here,
+ * so the exclusion sits next to the code that defines them and cannot be missed
+ * by someone adding a module.
+ *
+ * Currently narrowed (the rest is the intended surface):
+ * - `services/retry-strategy` — decision functions only; `parseRetryAfter` and
+ *   `addJitter` are backoff internals.
+ * - `services/circuit-breaker` — `CircuitOpenError` + `resetCircuitBreakers`;
+ *   the `CircuitBreaker` class is wired by the shared HTTP client, not by
+ *   services.
+ * - `services/service-keys` — verify/inspect only; signing, the key bundle and
+ *   `_resetServiceKeysForTests` stay inside.
+ * - `utils/jwk` — constants, shapes, decoders and the two signer-facing helpers
+ *   platform needs; `jwkThumbprint` / `publicKeyFromJwk` stay inside.
+ *
+ * api-core's own modules and its `testing/` helpers reach the excluded symbols
+ * by DEEP import (`@pipeline-builder/api-core/lib/services/service-keys.js`),
+ * which is also how the unit tests reach them.
+ */
 export * from './types/index.js';
 export * from './constants/index.js';
 export * from './utils/index.js';

package/lib/index.js

@@ -24,6 +24,7 @@
  * - getParam, getOrgId — request parameter extraction
  * - parseQueryInt, parseQueryString — query string parsing
  * - getIdentity — identity extraction from requests
+ * - actorId — the audit actor for a route context (one `system` sentinel)
  * - errorMessage — safe error-to-string conversion
  *
  * **Constants**
@@ -35,6 +36,7 @@
  * - CacheService — in-memory TTL cache
  * - ComplianceClient — compliance service client
  * - EntityEventEmitter — domain event pub/sub
+ * - retryForever — capped-backoff wait for a dependency that must come up
  *
  * **Errors**
  * - AppError, NotFoundError, ForbiddenError — typed HTTP error classes
@@ -48,6 +50,30 @@
  * **OpenAPI**
  * - Schema registry and spec generation
  */
+/**
+ * PUBLIC SURFACE POLICY
+ *
+ * The root re-exports the ten sub-barrels, and each SUB-BARREL is the allow-list
+ * for its own area — that is where a module is either `export *`'d or narrowed
+ * to the names services may use. Internals are excluded there rather than here,
+ * so the exclusion sits next to the code that defines them and cannot be missed
+ * by someone adding a module.
+ *
+ * Currently narrowed (the rest is the intended surface):
+ * - `services/retry-strategy` — decision functions only; `parseRetryAfter` and
+ *   `addJitter` are backoff internals.
+ * - `services/circuit-breaker` — `CircuitOpenError` + `resetCircuitBreakers`;
+ *   the `CircuitBreaker` class is wired by the shared HTTP client, not by
+ *   services.
+ * - `services/service-keys` — verify/inspect only; signing, the key bundle and
+ *   `_resetServiceKeysForTests` stay inside.
+ * - `utils/jwk` — constants, shapes, decoders and the two signer-facing helpers
+ *   platform needs; `jwkThumbprint` / `publicKeyFromJwk` stay inside.
+ *
+ * api-core's own modules and its `testing/` helpers reach the excluded symbols
+ * by DEEP import (`@pipeline-builder/api-core/lib/services/service-keys.js`),
+ * which is also how the unit tests reach them.
+ */
 // Types
 export * from './types/index.js';
 // Constants
@@ -68,4 +94,4 @@ export * from './errors/index.js';
 export * from './validation/index.js';
 // OpenAPI
 export * from './openapi/index.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/auth.d.ts

@@ -1,5 +1,7 @@
 import type { Request, Response, NextFunction } from 'express';
+import { type OrgAdminAssuranceMachines } from './route-table.js';
 import { type AssuranceLevel, type JwtPayload } from '../types/common.js';
+import { ErrorCode } from '../types/error-codes.js';
 import { type Permission } from '../types/permissions.js';
 /**
  * Verify a token that speaks for a PERSON — access, step-up, and the token an
@@ -157,6 +159,61 @@ export interface AssuranceOptions {
  * of "is this session MFA-grade" in the codebase.
  */
 export declare function requireAssurance(options: AssuranceOptions): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Handler-level twin of {@link requireAssurance}, for a route where only SOME
+ * requests must be MFA-grade — e.g. a policy route on which TIGHTENING a setting
+ * stays open to a single-factor session (so an admin without MFA can adopt it)
+ * but LOOSENING it does not. Same rules and the same three refusals. Returns
+ * true when the request was REFUSED (a response has been sent).
+ */
+export declare function refuseWeakSession(req: Request, res: Response, options: AssuranceOptions): boolean;
+/** What {@link requireOrgAdminAssurance} demands of a route. */
+export interface OrgAdminAssuranceOptions {
+    /** What a machine credential (PAT, service account, machine session) meets on
+     *  this route while the policy is on — see {@link OrgAdminAssuranceMachines}.
+     *  Required, so every route states its decision rather than inheriting one. */
+    machines: OrgAdminAssuranceMachines;
+}
+/** `details.reason` on a refusal by {@link requireOrgAdminAssurance}, so the UI
+ *  can say it is the ORG's policy asking, not the route's own requirement. */
+export declare const ORG_ADMIN_MFA_REASON = "org_admin_policy";
+/**
+ * The refusal {@link requireOrgAdminAssurance} would send for these claims, or
+ * `undefined` when the request may proceed. Exported so a handler whose policy
+ * applies to only PART of a route (e.g. `generate-token`, where opening a new
+ * machine credential is gated but renewing an existing one is not) applies the
+ * exact same rule rather than a copy of it.
+ */
+export declare function orgAdminAssuranceRefusal(claims: JwtPayload | undefined, options: OrgAdminAssuranceOptions): {
+    status: number;
+    code: ErrorCode;
+    message: string;
+    reason: 'machine_principal' | 'weak_session';
+} | undefined;
+/**
+ * Apply {@link orgAdminAssuranceRefusal} and send its refusal. Returns true when
+ * the request was REFUSED (a response has been sent). For handler-level use;
+ * routes use {@link requireOrgAdminAssurance}.
+ */
+export declare function refuseForOrgAdminAssurance(req: Request, res: Response, options: OrgAdminAssuranceOptions): boolean;
+/**
+ * The org policy "administrative actions require MFA" (`adminActionsRequireMfa`).
+ *
+ * Unlike {@link requireAssurance}, the requirement is the ORG's choice, not the
+ * route's: the gate reads the `org_admin_aal` claim, set at token issue from the
+ * active org's policy (strictest across its ancestors), so a service that cannot
+ * read the org document still enforces it. With the policy off the gate is a
+ * no-op; with it on, a single-factor session is refused 401 `MFA_REQUIRED`
+ * (with `details.reason: 'org_admin_policy'`) — the same code the client already
+ * turns into "enrol a factor / sign in with it", never a sign-out.
+ *
+ * `machines` is decided per route (see {@link OrgAdminAssuranceMachines}): the
+ * policy is about how strongly a PERSON's session was opened, so automation that
+ * legitimately drives a route keeps working (`allow`), while a route that mints
+ * a further credential refuses machines outright (`refuse`, 403
+ * `HUMAN_SESSION_REQUIRED` — the same refusal `requireAssurance` gives them).
+ */
+export declare function requireOrgAdminAssurance(options: OrgAdminAssuranceOptions): (req: Request, res: Response, next: NextFunction) => void;
 /**
  * Whether a verified token carries a well-formed identity: a known
  * `principalType` and `token_use`, and the claims that kind of principal must