@pipeline-builder/pipeline-data 4.3.11 → 4.3.13

package/lib/api/managed-toolchain.js

@@ -0,0 +1,443 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * THE resolver for the managed toolchain (docs/plans/bootstrap-image-versioning.md
+ * §2). `pipeline-bootstrap@V` and `cdk-synth@V` are two SYSTEM-ORG plugin rows
+ * that share one release version `V`; every path that can resolve a managed
+ * name answers from here and nothing else may:
+ *
+ *   release pin given → that release, if it EXISTS (yanked / deprecated /
+ *                       never-promoted still resolve, with a warning; deleted ⇒ 404)
+ *   else org default  → the NEAREST `org_toolchain_default` walking caller → … → root
+ *   else canary       → the NEAREST `toolchain_rollout` membership, served only
+ *                       while it passes the scan + metadata guards
+ *   else platform     → `toolchain_platform_default`
+ *   else              → 409 TOOLCHAIN_NO_DEFAULT (never "highest version", D11)
+ *
+ * - Reads are ELEVATED (`runWithTenantContext({ isSuperAdmin: true })`, as
+ *   `versionReferences` does) and touch SYSTEM-ORG plugin rows only: the owner
+ *   rank of `pluginResolutionOrderBy` is never consulted, so a same-named row in
+ *   any other org is never a candidate.
+ * - Eligibility (D15) is a SET-time rule ({@link isEligibleRelease}); at resolve
+ *   time a pin / org default only has to exist.
+ * - Both halves always come from ONE release (`TOOLCHAIN_PAIR_MISMATCH` otherwise).
+ * - The answer carries `resolvedVia` and nothing about any other org: no
+ *   rollout membership, no ancestor's settings.
+ */
+import { AppError, compareSemver, createLogger, envInt, ErrorCode, fetchParentOrgId, getStatusForErrorCode, isSystemOrgId, MANAGED_TOOLCHAIN, MANAGED_TOOLCHAIN_PLUGINS, MAX_ORG_DEPTH, SYSTEM_ORG_ID, TOOLCHAIN_RELEASE_VERSION_PATTERN, toolchainFromMetadata, toOrgIdString, } from '@pipeline-builder/api-core';
+import { and, eq, inArray, isNull, sql } from 'drizzle-orm';
+import { schema } from '../database/drizzle-schema.js';
+import { runWithTenantContext, withTenantTx } from '../database/tenancy.js';
+const logger = createLogger('managed-toolchain');
+/** A resolver refusal: `code` is TOOLCHAIN_NO_DEFAULT, NOT_FOUND, TOOLCHAIN_PAIR_MISMATCH or VALIDATION_ERROR. */
+export class ManagedToolchainError extends AppError {
+    constructor(code, message, details) {
+        super(getStatusForErrorCode(code), code, message, details);
+        this.name = 'ManagedToolchainError';
+    }
+}
+/** Whether `version` is a release version (`MAJOR.MINOR.PATCH`). */
+export function isToolchainReleaseVersion(version) {
+    return typeof version === 'string' && TOOLCHAIN_RELEASE_VERSION_PATTERN.test(version);
+}
+const { bootstrap: BOOTSTRAP, synth: SYNTH } = MANAGED_TOOLCHAIN;
+/** The release row and both SYSTEM-ORG halves of `releaseVersion` (deleted rows excluded). */
+export async function loadReleaseHalves(db, releaseVersion) {
+    const [releases, rows] = await Promise.all([
+        db.select().from(schema.toolchainRelease).where(eq(schema.toolchainRelease.releaseVersion, releaseVersion)),
+        db.select().from(schema.plugin).where(and(eq(schema.plugin.orgId, SYSTEM_ORG_ID), inArray(schema.plugin.name, [...MANAGED_TOOLCHAIN_PLUGINS]), eq(schema.plugin.version, releaseVersion), isNull(schema.plugin.deletedAt))),
+    ]);
+    const plugins = rows;
+    return {
+        releaseVersion,
+        release: releases[0] ?? null,
+        bootstrap: plugins.find((p) => p.name === BOOTSTRAP) ?? null,
+        synth: plugins.find((p) => p.name === SYNTH) ?? null,
+    };
+}
+/** The NEAREST row of `table` (keyed by `org_id`) on `chain` (own org first). */
+async function nearestOnChain(db, table, chain) {
+    if (chain.length === 0)
+        return null;
+    const rows = await db.select({ orgId: table.orgId, releaseVersion: table.releaseVersion })
+        .from(table)
+        .where(inArray(sql `lower(${table.orgId})`, [...chain]));
+    let best = null;
+    for (const r of rows) {
+        const depth = chain.indexOf(r.orgId.toLowerCase());
+        if (depth >= 0 && (!best || depth < best.depth))
+            best = { depth, releaseVersion: r.releaseVersion };
+    }
+    return best;
+}
+async function currentPlatformDefault(db) {
+    const rows = await db.select({ releaseVersion: schema.toolchainPlatformDefault.releaseVersion })
+        .from(schema.toolchainPlatformDefault).limit(1);
+    return rows[0]?.releaseVersion ?? null;
+}
+/** Whether `releaseVersion` has ever been (or is) the platform default. */
+async function wasPlatformDefault(db, releaseVersion) {
+    const [history, current] = await Promise.all([
+        db.select({ id: schema.toolchainDefaultHistory.id }).from(schema.toolchainDefaultHistory)
+            .where(eq(schema.toolchainDefaultHistory.releaseVersion, releaseVersion)).limit(1),
+        currentPlatformDefault(db),
+    ]);
+    return history.length > 0 || current === releaseVersion;
+}
+/** Whether ANY org has an org default or a canary membership (else no walk is needed). */
+async function anyOrgSettings(db) {
+    const [defaults, rollout] = await Promise.all([
+        db.select({ orgId: schema.orgToolchainDefault.orgId }).from(schema.orgToolchainDefault).limit(1),
+        db.select({ orgId: schema.toolchainRollout.orgId }).from(schema.toolchainRollout).limit(1),
+    ]);
+    return defaults.length > 0 || rollout.length > 0;
+}
+// -----------------------------------------------------------------------------
+// The org chain (caller → … → root)
+// -----------------------------------------------------------------------------
+/**
+ * The caller's chain, own org first, lowercased: `[self, parent, …, root]`.
+ * The same parent walk as `org-reachability.ts` (platform's
+ * `GET /organization/:id/parent`), cycle-safe and capped at `MAX_ORG_DEPTH` like
+ * `reporting-retention.ts` — but FAIL-CLOSED: a lookup failure, a cycle or an
+ * over-deep chain throws rather than resolving the wrong org's toolchain.
+ */
+export async function toolchainOrgChain(orgId, getParent) {
+    const self = orgId.toLowerCase();
+    const chain = [self];
+    if (isSystemOrgId(self))
+        return chain;
+    let current = self;
+    for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {
+        const parent = toOrgIdString(await getParent(current))?.toLowerCase();
+        if (!parent || parent === current)
+            return chain;
+        if (chain.includes(parent)) {
+            throw new ManagedToolchainError(ErrorCode.INTERNAL_ERROR, 'The organization hierarchy has a cycle; the toolchain release cannot be resolved.', { orgId: self });
+        }
+        chain.push(parent);
+        current = parent;
+    }
+    throw new ManagedToolchainError(ErrorCode.INTERNAL_ERROR, `The organization hierarchy is deeper than ${MAX_ORG_DEPTH}; the toolchain release cannot be resolved.`, { orgId: self });
+}
+/** Parent lookups are cached briefly: one synth makes several lookups for the same org. */
+const PARENT_CACHE_TTL_MS = 30_000;
+const PARENT_CACHE_MAX = 5_000;
+const parentCache = new Map();
+async function platformParent(orgId) {
+    const hit = parentCache.get(orgId);
+    if (hit && Date.now() - hit.at < PARENT_CACHE_TTL_MS)
+        return hit.parent;
+    // A system-scoped service token; a non-2xx THROWS (fail-closed, see toolchainOrgChain).
+    const parent = await fetchParentOrgId(orgId, { authOrgId: SYSTEM_ORG_ID, throwOnHttpError: true, timeout: 5_000 });
+    if (parentCache.size >= PARENT_CACHE_MAX)
+        parentCache.clear();
+    parentCache.set(orgId, { parent, at: Date.now() });
+    return parent;
+}
+const productionDeps = {
+    read: (fn) => runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => fn(tx))),
+    getParent: platformParent,
+};
+let defaultDeps = productionDeps;
+/** Test hook: replace the resolver's reads and hierarchy (null restores production). */
+export function setManagedToolchainDepsForTests(deps) {
+    defaultDeps = deps ?? productionDeps;
+}
+const isYanked = (p) => p.yankedAt !== null || p.lifecycle === 'yanked';
+const isDeprecated = (p) => p.deprecatedAt !== null || p.lifecycle === 'deprecated';
+/** Whether both halves are present (the release EXISTS). */
+export function releaseExists(h) {
+    return h.release !== null && h.bootstrap !== null && h.synth !== null;
+}
+export function releaseLifecycleProblems(h) {
+    if (!releaseExists(h))
+        return ['missing'];
+    const halves = [h.bootstrap, h.synth];
+    const out = [];
+    if (halves.some((p) => !p.isActive))
+        out.push('inactive');
+    if (halves.some(isYanked))
+        out.push('yanked');
+    if (halves.some(isDeprecated))
+        out.push('deprecated');
+    return out;
+}
+/**
+ * The bootstrap half's toolchain metadata (`pipelineManager`, `awsCdk`, …), or
+ * null when it carries no complete, valid one. Upload persists it on the row's
+ * `metadata` as flat `toolchain.<field>` keys (api-core `toolchainMetadata`).
+ */
+export function bootstrapToolchainOf(row) {
+    return row ? toolchainFromMetadata(row.metadata) : null;
+}
+/** `PLUGIN_VULN_MAX_FINDINGS` (default 0): the fixable-Critical floor a release must be within. */
+function vulnFloor() {
+    return envInt('PLUGIN_VULN_MAX_FINDINGS', 0, { min: 0 });
+}
+/**
+ * The §8 candidate guards (pair, scan, metadata) a release fails, as their
+ * error codes — empty when it passes. The canary gate and concurrency are the
+ * platform-default service's; a canary is served only while this is empty.
+ */
+export function toolchainCandidateProblems(h) {
+    if (!releaseExists(h) || releaseLifecycleProblems(h).length > 0)
+        return [ErrorCode.TOOLCHAIN_GUARD_PAIR_INCOMPLETE];
+    const out = [];
+    const halves = [h.bootstrap, h.synth];
+    if (halves.some((p) => !p.scannedAt))
+        out.push(ErrorCode.TOOLCHAIN_GUARD_UNSCANNED);
+    else if (halves.some((p) => (p.vulnCriticalFixable ?? 0) > vulnFloor()))
+        out.push(ErrorCode.TOOLCHAIN_GUARD_VULN_FLOOR);
+    if (!bootstrapToolchainOf(h.bootstrap))
+        out.push(ErrorCode.TOOLCHAIN_GUARD_METADATA);
+    return out;
+}
+/** Warnings for a release that EXISTS but is no longer (or never was) eligible. */
+function standingWarnings(h, promoted, via) {
+    const ref = `Toolchain release ${h.releaseVersion}`;
+    const out = [];
+    const yanked = [h.bootstrap, h.synth].find(isYanked);
+    if (yanked) {
+        out.push({
+            code: 'TOOLCHAIN_RELEASE_YANKED',
+            severity: 'warning',
+            message: `${ref} is yanked${yanked.yankReason ? `: ${yanked.yankReason}` : ''}. It resolves only because it is selected exactly; move to a supported release.`,
+        });
+    }
+    const deprecated = [h.bootstrap, h.synth].find(isDeprecated);
+    if (deprecated) {
+        out.push({
+            code: 'TOOLCHAIN_RELEASE_DEPRECATED',
+            severity: 'warning',
+            message: `${ref} is deprecated${deprecated.deprecationMessage ? `: ${deprecated.deprecationMessage}` : ''}.`,
+        });
+    }
+    if ([h.bootstrap, h.synth].some((p) => !p.isActive)) {
+        out.push({ code: 'TOOLCHAIN_RELEASE_INACTIVE', severity: 'warning', message: `${ref} is inactive; move to a supported release.` });
+    }
+    if (!promoted && (via === 'pin' || via === 'org-default')) {
+        out.push({
+            code: 'TOOLCHAIN_RELEASE_NOT_PROMOTED',
+            severity: 'warning',
+            message: `${ref} was never the platform default and is not in a canary for your organization; it resolves only because it is selected exactly.`,
+        });
+    }
+    return out;
+}
+// -----------------------------------------------------------------------------
+// Resolution
+// -----------------------------------------------------------------------------
+function pairOf(h, via) {
+    if (!releaseExists(h)) {
+        // A default (platform or org) whose halves are gone is a broken invariant
+        // (in-use protection counts defaults): refused, never served.
+        throw new ManagedToolchainError(ErrorCode.TOOLCHAIN_PAIR_MISMATCH, `Toolchain release ${h.releaseVersion} (${via}) is incomplete; it is never served.`, {
+            releaseVersion: h.releaseVersion,
+            missing: [...(h.bootstrap ? [] : [BOOTSTRAP]), ...(h.synth ? [] : [SYNTH]), ...(h.release ? [] : ['toolchain_release'])],
+        });
+    }
+    if (h.bootstrap.version !== h.releaseVersion || h.synth.version !== h.releaseVersion) {
+        throw new ManagedToolchainError(ErrorCode.TOOLCHAIN_PAIR_MISMATCH, `Toolchain halves disagree (${BOOTSTRAP}@${h.bootstrap.version}, ${SYNTH}@${h.synth.version}); never served.`, {
+            releaseVersion: h.releaseVersion,
+        });
+    }
+    return { bootstrap: h.bootstrap, synth: h.synth };
+}
+/** The resolution inside one elevated read, over a known chain. */
+async function resolveOnChain(db, chain, releasePin) {
+    const canary = await nearestOnChain(db, schema.toolchainRollout, chain);
+    const answer = async (h, via) => {
+        const pair = pairOf(h, via);
+        const promoted = via === 'pin' || via === 'org-default'
+            ? (await wasPlatformDefault(db, h.releaseVersion)) || canary?.releaseVersion === h.releaseVersion
+            : true;
+        return { releaseVersion: h.releaseVersion, resolvedVia: via, ...pair, warnings: standingWarnings({ ...h, ...pair }, promoted, via) };
+    };
+    if (releasePin !== undefined) {
+        if (!isToolchainReleaseVersion(releasePin)) {
+            throw new ManagedToolchainError(ErrorCode.VALIDATION_ERROR, 'releasePin must be a release version (MAJOR.MINOR.PATCH, e.g. 1.4.2).', { releasePin });
+        }
+        const h = await loadReleaseHalves(db, releasePin);
+        if (!releaseExists(h)) {
+            throw new ManagedToolchainError(ErrorCode.NOT_FOUND, `Toolchain release ${releasePin} does not exist (or was deleted). Pin an eligible release, or remove toolchain.release to follow your organization's default.`, {
+                reason: 'toolchain_release_not_found', releaseVersion: releasePin,
+            });
+        }
+        return answer(h, 'pin');
+    }
+    const orgDefault = await nearestOnChain(db, schema.orgToolchainDefault, chain);
+    if (orgDefault)
+        return answer(await loadReleaseHalves(db, orgDefault.releaseVersion), 'org-default');
+    if (canary) {
+        const h = await loadReleaseHalves(db, canary.releaseVersion);
+        const problems = toolchainCandidateProblems(h);
+        if (problems.length === 0)
+            return answer(h, 'canary');
+        // Members fall through to the platform default. Logged, never returned:
+        // the answer must not reveal canary membership.
+        logger.warn('Canary toolchain release fails its guards; serving the platform default', { releaseVersion: canary.releaseVersion, problems });
+    }
+    const platform = await currentPlatformDefault(db);
+    if (!platform) {
+        throw new ManagedToolchainError(ErrorCode.TOOLCHAIN_NO_DEFAULT, 'No platform default toolchain release is set. An operator must set one (init-platform does this on a fresh install).');
+    }
+    return answer(await loadReleaseHalves(db, platform), 'default');
+}
+/** {@link resolveManagedToolchain} with injected reads and hierarchy (tests). */
+export async function resolveManagedToolchainWith(deps, caller, opts = {}) {
+    const self = caller.orgId.toLowerCase();
+    // Walk the hierarchy only when some org has a setting (and outside the transaction).
+    const walk = await deps.read((db) => anyOrgSettings(db));
+    const chain = walk ? await toolchainOrgChain(self, deps.getParent) : [self];
+    return deps.read((db) => resolveOnChain(db, chain, opts.releasePin));
+}
+/**
+ * Resolve the managed toolchain release for `caller` (see the module doc).
+ * Throws {@link ManagedToolchainError}: TOOLCHAIN_NO_DEFAULT (409, no platform
+ * default), NOT_FOUND (404, a missing / deleted pin), TOOLCHAIN_PAIR_MISMATCH
+ * (500), VALIDATION_ERROR (400, a malformed pin).
+ */
+export function resolveManagedToolchain(caller, opts = {}) {
+    return resolveManagedToolchainWith(defaultDeps, caller, opts);
+}
+/** {@link isEligibleRelease} with injected reads and hierarchy (tests). */
+export async function isEligibleReleaseWith(deps, orgId, releaseVersion) {
+    if (!isToolchainReleaseVersion(releaseVersion))
+        return false;
+    const self = orgId.toLowerCase();
+    const halves = await deps.read((db) => loadReleaseHalves(db, releaseVersion));
+    if (releaseLifecycleProblems(halves).length > 0)
+        return false;
+    if (await deps.read((db) => wasPlatformDefault(db, releaseVersion)))
+        return true;
+    const walk = await deps.read((db) => anyOrgSettings(db));
+    if (!walk)
+        return false;
+    const chain = await toolchainOrgChain(self, deps.getParent);
+    const canary = await deps.read((db) => nearestOnChain(db, schema.toolchainRollout, chain));
+    return canary?.releaseVersion === releaseVersion;
+}
+/**
+ * D15: whether `orgId` may SET `releaseVersion` as a pipeline pin or its org
+ * default — both halves live (active, unyanked, not deprecated) AND either it
+ * has been the platform default or it is the caller's canary (nearest
+ * membership on its chain).
+ */
+export function isEligibleRelease(orgId, releaseVersion) {
+    return isEligibleReleaseWith(defaultDeps, orgId, releaseVersion);
+}
+/** {@link readOrgToolchainOverview} with injected reads and hierarchy (tests). */
+export async function readOrgToolchainOverviewWith(deps, orgId) {
+    const self = orgId.toLowerCase();
+    const walk = await deps.read((db) => anyOrgSettings(db));
+    const chain = walk ? await toolchainOrgChain(self, deps.getParent) : [self];
+    return deps.read(async (db) => {
+        const rows = await db.select().from(schema.orgToolchainDefault)
+            .where(inArray(sql `lower(${schema.orgToolchainDefault.orgId})`, chain));
+        const depthOf = (r) => chain.indexOf(r.orgId.toLowerCase());
+        const ownDefault = rows.find((r) => depthOf(r) === 0) ?? null;
+        const nearest = rows.filter((r) => depthOf(r) >= 0).sort((a, b) => depthOf(a) - depthOf(b))[0] ?? null;
+        const [canary, platformDefault, resolution] = await Promise.all([
+            nearestOnChain(db, schema.toolchainRollout, chain),
+            currentPlatformDefault(db),
+            resolveOnChain(db, chain),
+        ]);
+        return {
+            chain,
+            effective: { releaseVersion: resolution.releaseVersion, resolvedVia: resolution.resolvedVia, warnings: resolution.warnings },
+            ownDefault,
+            inheritedFrom: !ownDefault && nearest ? { orgId: nearest.orgId, releaseVersion: nearest.releaseVersion } : null,
+            canaryRelease: canary?.releaseVersion ?? null,
+            platformDefault,
+        };
+    });
+}
+/**
+ * The caller org's toolchain overview (elevated reads, the same chain walk and
+ * precedence as {@link resolveManagedToolchain}). Throws what the resolver
+ * throws — TOOLCHAIN_NO_DEFAULT (409) when nothing resolves at all.
+ */
+export function readOrgToolchainOverview(orgId) {
+    return readOrgToolchainOverviewWith(defaultDeps, orgId);
+}
+/** {@link listEligibleReleases} with injected reads and hierarchy (tests). */
+export async function listEligibleReleasesWith(deps, orgId) {
+    const self = orgId.toLowerCase();
+    const walk = await deps.read((db) => anyOrgSettings(db));
+    const chain = walk ? await toolchainOrgChain(self, deps.getParent) : [self];
+    return deps.read(async (db) => {
+        const [releases, rows, history, platformDefault, canary] = await Promise.all([
+            db.select().from(schema.toolchainRelease),
+            db.select().from(schema.plugin).where(and(eq(schema.plugin.orgId, SYSTEM_ORG_ID), inArray(schema.plugin.name, [...MANAGED_TOOLCHAIN_PLUGINS]), isNull(schema.plugin.deletedAt))),
+            db.select({ releaseVersion: schema.toolchainDefaultHistory.releaseVersion }).from(schema.toolchainDefaultHistory),
+            currentPlatformDefault(db),
+            nearestOnChain(db, schema.toolchainRollout, chain),
+        ]);
+        const promoted = new Set(history.map((h) => h.releaseVersion));
+        if (platformDefault)
+            promoted.add(platformDefault);
+        const out = [];
+        for (const release of releases) {
+            const v = release.releaseVersion;
+            const halves = {
+                releaseVersion: v,
+                release,
+                bootstrap: rows.find((p) => p.name === BOOTSTRAP && p.version === v) ?? null,
+                synth: rows.find((p) => p.name === SYNTH && p.version === v) ?? null,
+            };
+            if (!releaseExists(halves) || releaseLifecycleProblems(halves).length > 0)
+                continue;
+            const isCanary = canary?.releaseVersion === v;
+            if (!promoted.has(v) && !isCanary)
+                continue;
+            out.push({ releaseVersion: v, release, bootstrap: halves.bootstrap, synth: halves.synth, isPlatformDefault: platformDefault === v, isCanary });
+        }
+        out.sort((a, b) => compareSemver(b.releaseVersion, a.releaseVersion));
+        return { platformDefault, releases: out };
+    });
+}
+/**
+ * Every release `orgId` may SET as a pipeline pin or its org default (D15, the
+ * same rule as {@link isEligibleRelease}), newest first. Never another org's
+ * data: a canary appears only when it is the caller's own (nearest) membership.
+ */
+export function listEligibleReleases(orgId) {
+    return listEligibleReleasesWith(defaultDeps, orgId);
+}
+// -----------------------------------------------------------------------------
+// Caller helpers
+// -----------------------------------------------------------------------------
+/**
+ * Each resolver refusal code's step-resolution refusal (anything else is
+ * `toolchain_unresolved`). `details` rides along except for NO_DEFAULT, which
+ * carries none worth showing.
+ */
+const REFUSAL_BY_CODE = {
+    [ErrorCode.NOT_FOUND]: { code: 'NOT_FOUND', reason: 'toolchain_release_not_found', details: true },
+    [ErrorCode.VALIDATION_ERROR]: { code: 'NOT_FOUND', reason: 'toolchain_release_invalid', details: true },
+    [ErrorCode.TOOLCHAIN_NO_DEFAULT]: { code: 'PLUGIN_UNAVAILABLE', reason: 'toolchain_no_default', details: false },
+};
+const UNRESOLVED_REFUSAL = { code: 'PLUGIN_UNAVAILABLE', reason: 'toolchain_unresolved', details: true };
+/** The resolver's error as the refusal shape step resolution reports (contract check, declared side, facts). */
+export function managedToolchainRefusal(err) {
+    const r = REFUSAL_BY_CODE[err.code] ?? UNRESOLVED_REFUSAL;
+    return { code: r.code, reason: r.reason, message: err.message, ...(r.details && err.details ? { details: err.details } : {}) };
+}
+/**
+ * Resolve ONE managed half for a step: the plugin row plus the resolution, or
+ * the refusal. Any non-resolver error (a database or hierarchy failure)
+ * propagates.
+ */
+export async function resolveManagedToolchainHalf(caller, name, opts = {}) {
+    try {
+        const resolution = await resolveManagedToolchain(caller, opts);
+        return { plugin: name === BOOTSTRAP ? resolution.bootstrap : resolution.synth, resolution };
+    }
+    catch (err) {
+        if (err instanceof ManagedToolchainError)
+            return { refusal: managedToolchainRefusal(err), error: err };
+        throw err;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"managed-toolchain.js","sources":["../../src/api/managed-toolchain.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * THE resolver for the managed toolchain (docs/plans/bootstrap-image-versioning.md\n * §2). `pipeline-bootstrap@V` and `cdk-synth@V` are two SYSTEM-ORG plugin rows\n * that share one release version `V`; every path that can resolve a managed\n * name answers from here and nothing else may:\n *\n *   release pin given → that release, if it EXISTS (yanked / deprecated /\n *                       never-promoted still resolve, with a warning; deleted ⇒ 404)\n *   else org default  → the NEAREST `org_toolchain_default` walking caller → … → root\n *   else canary       → the NEAREST `toolchain_rollout` membership, served only\n *                       while it passes the scan + metadata guards\n *   else platform     → `toolchain_platform_default`\n *   else              → 409 TOOLCHAIN_NO_DEFAULT (never \"highest version\", D11)\n *\n * - Reads are ELEVATED (`runWithTenantContext({ isSuperAdmin: true })`, as\n *   `versionReferences` does) and touch SYSTEM-ORG plugin rows only: the owner\n *   rank of `pluginResolutionOrderBy` is never consulted, so a same-named row in\n *   any other org is never a candidate.\n * - Eligibility (D15) is a SET-time rule ({@link isEligibleRelease}); at resolve\n *   time a pin / org default only has to exist.\n * - Both halves always come from ONE release (`TOOLCHAIN_PAIR_MISMATCH` otherwise).\n * - The answer carries `resolvedVia` and nothing about any other org: no\n *   rollout membership, no ancestor's settings.\n */\n\nimport {\n  AppError, compareSemver, createLogger, envInt, ErrorCode, fetchParentOrgId, getStatusForErrorCode, isSystemOrgId,\n  MANAGED_TOOLCHAIN, MANAGED_TOOLCHAIN_PLUGINS, MAX_ORG_DEPTH, SYSTEM_ORG_ID, TOOLCHAIN_RELEASE_VERSION_PATTERN, toolchainFromMetadata, toOrgIdString,\n  type GetParentOrgId, type ManagedToolchainPlugin, type PluginToolchain, type ToolchainResolvedVia,\n} from '@pipeline-builder/api-core';\nimport { and, eq, inArray, isNull, sql } from 'drizzle-orm';\nimport type { CrudTx } from './crud-service.js';\nimport type { ResolutionRefusal } from './plugin-resolution.js';\nimport { schema, type OrgToolchainDefault, type Plugin, type ToolchainRelease } from '../database/drizzle-schema.js';\nimport { runWithTenantContext, withTenantTx } from '../database/tenancy.js';\n\nconst logger = createLogger('managed-toolchain');\n\n// -----------------------------------------------------------------------------\n// Public shapes\n// -----------------------------------------------------------------------------\n\n/** A non-fatal note on a resolved release (synth prints it). */\nexport interface ManagedToolchainWarning {\n  code: string;\n  message: string;\n  severity: 'info' | 'warning' | 'error';\n}\n\n/** One release, both halves. */\nexport interface ManagedToolchainResolution {\n  releaseVersion: string;\n  resolvedVia: ToolchainResolvedVia;\n  bootstrap: Plugin;\n  synth: Plugin;\n  warnings: ManagedToolchainWarning[];\n}\n\n/** A resolver refusal: `code` is TOOLCHAIN_NO_DEFAULT, NOT_FOUND, TOOLCHAIN_PAIR_MISMATCH or VALIDATION_ERROR. */\nexport class ManagedToolchainError extends AppError {\n  constructor(code: ErrorCode, message: string, details?: Record<string, unknown>) {\n    super(getStatusForErrorCode(code), code, message, details);\n    this.name = 'ManagedToolchainError';\n  }\n}\n\n/** The caller a resolution runs for. */\nexport interface ManagedToolchainCaller {\n  orgId: string;\n}\n\n/** Whether `version` is a release version (`MAJOR.MINOR.PATCH`). */\nexport function isToolchainReleaseVersion(version: unknown): version is string {\n  return typeof version === 'string' && TOOLCHAIN_RELEASE_VERSION_PATTERN.test(version);\n}\n\n// -----------------------------------------------------------------------------\n// Data access (system-org rows, elevated)\n// -----------------------------------------------------------------------------\n\n/** What the resolver reads with: a drizzle transaction (or any drizzle database in tests). */\nexport type ToolchainDb = Pick<CrudTx, 'select'>;\n\n/** How the resolver reads and walks the org tree (injectable for tests). */\nexport interface ManagedToolchainDeps {\n  /** Run `fn` with ELEVATED reads. */\n  read<T>(fn: (db: ToolchainDb) => Promise<T>): Promise<T>;\n  /** An org's direct parent, or undefined for a root. Throws when it can't tell. */\n  getParent: GetParentOrgId;\n}\n\n/** Both halves of one release as stored, with the release row. */\nexport interface ReleaseHalves {\n  releaseVersion: string;\n  release: ToolchainRelease | null;\n  bootstrap: Plugin | null;\n  synth: Plugin | null;\n}\n\nconst { bootstrap: BOOTSTRAP, synth: SYNTH } = MANAGED_TOOLCHAIN;\n\n/** The release row and both SYSTEM-ORG halves of `releaseVersion` (deleted rows excluded). */\nexport async function loadReleaseHalves(db: ToolchainDb, releaseVersion: string): Promise<ReleaseHalves> {\n  const [releases, rows] = await Promise.all([\n    db.select().from(schema.toolchainRelease).where(eq(schema.toolchainRelease.releaseVersion, releaseVersion)),\n    db.select().from(schema.plugin).where(and(\n      eq(schema.plugin.orgId, SYSTEM_ORG_ID),\n      inArray(schema.plugin.name, [...MANAGED_TOOLCHAIN_PLUGINS]),\n      eq(schema.plugin.version, releaseVersion),\n      isNull(schema.plugin.deletedAt),\n    )),\n  ]);\n  const plugins = rows as Plugin[];\n  return {\n    releaseVersion,\n    release: (releases as ToolchainRelease[])[0] ?? null,\n    bootstrap: plugins.find((p) => p.name === BOOTSTRAP) ?? null,\n    synth: plugins.find((p) => p.name === SYNTH) ?? null,\n  };\n}\n\n/** A setting found on the caller's chain: which chain index, and its release. */\ninterface ChainSetting { depth: number; releaseVersion: string }\n\n/** The NEAREST row of `table` (keyed by `org_id`) on `chain` (own org first). */\nasync function nearestOnChain(\n  db: ToolchainDb,\n  table: typeof schema.orgToolchainDefault | typeof schema.toolchainRollout,\n  chain: readonly string[],\n): Promise<ChainSetting | null> {\n  if (chain.length === 0) return null;\n  const rows = await db.select({ orgId: table.orgId, releaseVersion: table.releaseVersion })\n    .from(table)\n    .where(inArray(sql<string>`lower(${table.orgId})`, [...chain])) as Array<{ orgId: string; releaseVersion: string }>;\n  let best: ChainSetting | null = null;\n  for (const r of rows) {\n    const depth = chain.indexOf(r.orgId.toLowerCase());\n    if (depth >= 0 && (!best || depth < best.depth)) best = { depth, releaseVersion: r.releaseVersion };\n  }\n  return best;\n}\n\nasync function currentPlatformDefault(db: ToolchainDb): Promise<string | null> {\n  const rows = await db.select({ releaseVersion: schema.toolchainPlatformDefault.releaseVersion })\n    .from(schema.toolchainPlatformDefault).limit(1) as Array<{ releaseVersion: string }>;\n  return rows[0]?.releaseVersion ?? null;\n}\n\n/** Whether `releaseVersion` has ever been (or is) the platform default. */\nasync function wasPlatformDefault(db: ToolchainDb, releaseVersion: string): Promise<boolean> {\n  const [history, current] = await Promise.all([\n    db.select({ id: schema.toolchainDefaultHistory.id }).from(schema.toolchainDefaultHistory)\n      .where(eq(schema.toolchainDefaultHistory.releaseVersion, releaseVersion)).limit(1),\n    currentPlatformDefault(db),\n  ]);\n  return (history as unknown[]).length > 0 || current === releaseVersion;\n}\n\n/** Whether ANY org has an org default or a canary membership (else no walk is needed). */\nasync function anyOrgSettings(db: ToolchainDb): Promise<boolean> {\n  const [defaults, rollout] = await Promise.all([\n    db.select({ orgId: schema.orgToolchainDefault.orgId }).from(schema.orgToolchainDefault).limit(1),\n    db.select({ orgId: schema.toolchainRollout.orgId }).from(schema.toolchainRollout).limit(1),\n  ]);\n  return (defaults as unknown[]).length > 0 || (rollout as unknown[]).length > 0;\n}\n\n// -----------------------------------------------------------------------------\n// The org chain (caller → … → root)\n// -----------------------------------------------------------------------------\n\n/**\n * The caller's chain, own org first, lowercased: `[self, parent, …, root]`.\n * The same parent walk as `org-reachability.ts` (platform's\n * `GET /organization/:id/parent`), cycle-safe and capped at `MAX_ORG_DEPTH` like\n * `reporting-retention.ts` — but FAIL-CLOSED: a lookup failure, a cycle or an\n * over-deep chain throws rather than resolving the wrong org's toolchain.\n */\nexport async function toolchainOrgChain(orgId: string, getParent: GetParentOrgId): Promise<string[]> {\n  const self = orgId.toLowerCase();\n  const chain = [self];\n  if (isSystemOrgId(self)) return chain;\n  let current = self;\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(current))?.toLowerCase();\n    if (!parent || parent === current) return chain;\n    if (chain.includes(parent)) {\n      throw new ManagedToolchainError(ErrorCode.INTERNAL_ERROR, 'The organization hierarchy has a cycle; the toolchain release cannot be resolved.', { orgId: self });\n    }\n    chain.push(parent);\n    current = parent;\n  }\n  throw new ManagedToolchainError(ErrorCode.INTERNAL_ERROR, `The organization hierarchy is deeper than ${MAX_ORG_DEPTH}; the toolchain release cannot be resolved.`, { orgId: self });\n}\n\n/** Parent lookups are cached briefly: one synth makes several lookups for the same org. */\nconst PARENT_CACHE_TTL_MS = 30_000;\nconst PARENT_CACHE_MAX = 5_000;\nconst parentCache = new Map<string, { parent: string | undefined; at: number }>();\n\nasync function platformParent(orgId: string): Promise<string | undefined> {\n  const hit = parentCache.get(orgId);\n  if (hit && Date.now() - hit.at < PARENT_CACHE_TTL_MS) return hit.parent;\n  // A system-scoped service token; a non-2xx THROWS (fail-closed, see toolchainOrgChain).\n  const parent = await fetchParentOrgId(orgId, { authOrgId: SYSTEM_ORG_ID, throwOnHttpError: true, timeout: 5_000 });\n  if (parentCache.size >= PARENT_CACHE_MAX) parentCache.clear();\n  parentCache.set(orgId, { parent, at: Date.now() });\n  return parent;\n}\n\nconst productionDeps: ManagedToolchainDeps = {\n  read: (fn) => runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => fn(tx))),\n  getParent: platformParent,\n};\nlet defaultDeps: ManagedToolchainDeps = productionDeps;\n\n/** Test hook: replace the resolver's reads and hierarchy (null restores production). */\nexport function setManagedToolchainDepsForTests(deps: ManagedToolchainDeps | null): void {\n  defaultDeps = deps ?? productionDeps;\n}\n\n// -----------------------------------------------------------------------------\n// Lifecycle, eligibility and the canary guards\n// -----------------------------------------------------------------------------\n\n/** Why a stored release is not LIVE (empty = live: both halves present, active, unyanked, not deprecated). */\nexport type ReleaseLifecycleProblem = 'missing' | 'inactive' | 'yanked' | 'deprecated';\n\nconst isYanked = (p: Plugin) => p.yankedAt !== null || p.lifecycle === 'yanked';\nconst isDeprecated = (p: Plugin) => p.deprecatedAt !== null || p.lifecycle === 'deprecated';\n\n/** Whether both halves are present (the release EXISTS). */\nexport function releaseExists(h: ReleaseHalves): h is ReleaseHalves & { bootstrap: Plugin; synth: Plugin } {\n  return h.release !== null && h.bootstrap !== null && h.synth !== null;\n}\n\nexport function releaseLifecycleProblems(h: ReleaseHalves): ReleaseLifecycleProblem[] {\n  if (!releaseExists(h)) return ['missing'];\n  const halves = [h.bootstrap, h.synth];\n  const out: ReleaseLifecycleProblem[] = [];\n  if (halves.some((p) => !p.isActive)) out.push('inactive');\n  if (halves.some(isYanked)) out.push('yanked');\n  if (halves.some(isDeprecated)) out.push('deprecated');\n  return out;\n}\n\n/**\n * The bootstrap half's toolchain metadata (`pipelineManager`, `awsCdk`, …), or\n * null when it carries no complete, valid one. Upload persists it on the row's\n * `metadata` as flat `toolchain.<field>` keys (api-core `toolchainMetadata`).\n */\nexport function bootstrapToolchainOf(row: Plugin | null | undefined): PluginToolchain | null {\n  return row ? toolchainFromMetadata(row.metadata) : null;\n}\n\n/** `PLUGIN_VULN_MAX_FINDINGS` (default 0): the fixable-Critical floor a release must be within. */\nfunction vulnFloor(): number {\n  return envInt('PLUGIN_VULN_MAX_FINDINGS', 0, { min: 0 });\n}\n\n/**\n * The §8 candidate guards (pair, scan, metadata) a release fails, as their\n * error codes — empty when it passes. The canary gate and concurrency are the\n * platform-default service's; a canary is served only while this is empty.\n */\nexport function toolchainCandidateProblems(h: ReleaseHalves): ErrorCode[] {\n  if (!releaseExists(h) || releaseLifecycleProblems(h).length > 0) return [ErrorCode.TOOLCHAIN_GUARD_PAIR_INCOMPLETE];\n  const out: ErrorCode[] = [];\n  const halves = [h.bootstrap, h.synth];\n  if (halves.some((p) => !p.scannedAt)) out.push(ErrorCode.TOOLCHAIN_GUARD_UNSCANNED);\n  else if (halves.some((p) => (p.vulnCriticalFixable ?? 0) > vulnFloor())) out.push(ErrorCode.TOOLCHAIN_GUARD_VULN_FLOOR);\n  if (!bootstrapToolchainOf(h.bootstrap)) out.push(ErrorCode.TOOLCHAIN_GUARD_METADATA);\n  return out;\n}\n\n/** Warnings for a release that EXISTS but is no longer (or never was) eligible. */\nfunction standingWarnings(h: ReleaseHalves & { bootstrap: Plugin; synth: Plugin }, promoted: boolean, via: ToolchainResolvedVia): ManagedToolchainWarning[] {\n  const ref = `Toolchain release ${h.releaseVersion}`;\n  const out: ManagedToolchainWarning[] = [];\n  const yanked = [h.bootstrap, h.synth].find(isYanked);\n  if (yanked) {\n    out.push({\n      code: 'TOOLCHAIN_RELEASE_YANKED',\n      severity: 'warning',\n      message: `${ref} is yanked${yanked.yankReason ? `: ${yanked.yankReason}` : ''}. It resolves only because it is selected exactly; move to a supported release.`,\n    });\n  }\n  const deprecated = [h.bootstrap, h.synth].find(isDeprecated);\n  if (deprecated) {\n    out.push({\n      code: 'TOOLCHAIN_RELEASE_DEPRECATED',\n      severity: 'warning',\n      message: `${ref} is deprecated${deprecated.deprecationMessage ? `: ${deprecated.deprecationMessage}` : ''}.`,\n    });\n  }\n  if ([h.bootstrap, h.synth].some((p) => !p.isActive)) {\n    out.push({ code: 'TOOLCHAIN_RELEASE_INACTIVE', severity: 'warning', message: `${ref} is inactive; move to a supported release.` });\n  }\n  if (!promoted && (via === 'pin' || via === 'org-default')) {\n    out.push({\n      code: 'TOOLCHAIN_RELEASE_NOT_PROMOTED',\n      severity: 'warning',\n      message: `${ref} was never the platform default and is not in a canary for your organization; it resolves only because it is selected exactly.`,\n    });\n  }\n  return out;\n}\n\n// -----------------------------------------------------------------------------\n// Resolution\n// -----------------------------------------------------------------------------\n\nfunction pairOf(h: ReleaseHalves, via: ToolchainResolvedVia): { bootstrap: Plugin; synth: Plugin } {\n  if (!releaseExists(h)) {\n    // A default (platform or org) whose halves are gone is a broken invariant\n    // (in-use protection counts defaults): refused, never served.\n    throw new ManagedToolchainError(ErrorCode.TOOLCHAIN_PAIR_MISMATCH, `Toolchain release ${h.releaseVersion} (${via}) is incomplete; it is never served.`, {\n      releaseVersion: h.releaseVersion,\n      missing: [...(h.bootstrap ? [] : [BOOTSTRAP]), ...(h.synth ? [] : [SYNTH]), ...(h.release ? [] : ['toolchain_release'])],\n    });\n  }\n  if (h.bootstrap.version !== h.releaseVersion || h.synth.version !== h.releaseVersion) {\n    throw new ManagedToolchainError(ErrorCode.TOOLCHAIN_PAIR_MISMATCH, `Toolchain halves disagree (${BOOTSTRAP}@${h.bootstrap.version}, ${SYNTH}@${h.synth.version}); never served.`, {\n      releaseVersion: h.releaseVersion,\n    });\n  }\n  return { bootstrap: h.bootstrap, synth: h.synth };\n}\n\n/** The resolution inside one elevated read, over a known chain. */\nasync function resolveOnChain(db: ToolchainDb, chain: readonly string[], releasePin?: string): Promise<ManagedToolchainResolution> {\n  const canary = await nearestOnChain(db, schema.toolchainRollout, chain);\n  const answer = async (h: ReleaseHalves, via: ToolchainResolvedVia): Promise<ManagedToolchainResolution> => {\n    const pair = pairOf(h, via);\n    const promoted = via === 'pin' || via === 'org-default'\n      ? (await wasPlatformDefault(db, h.releaseVersion)) || canary?.releaseVersion === h.releaseVersion\n      : true;\n    return { releaseVersion: h.releaseVersion, resolvedVia: via, ...pair, warnings: standingWarnings({ ...h, ...pair }, promoted, via) };\n  };\n\n  if (releasePin !== undefined) {\n    if (!isToolchainReleaseVersion(releasePin)) {\n      throw new ManagedToolchainError(ErrorCode.VALIDATION_ERROR, 'releasePin must be a release version (MAJOR.MINOR.PATCH, e.g. 1.4.2).', { releasePin });\n    }\n    const h = await loadReleaseHalves(db, releasePin);\n    if (!releaseExists(h)) {\n      throw new ManagedToolchainError(ErrorCode.NOT_FOUND, `Toolchain release ${releasePin} does not exist (or was deleted). Pin an eligible release, or remove toolchain.release to follow your organization's default.`, {\n        reason: 'toolchain_release_not_found', releaseVersion: releasePin,\n      });\n    }\n    return answer(h, 'pin');\n  }\n\n  const orgDefault = await nearestOnChain(db, schema.orgToolchainDefault, chain);\n  if (orgDefault) return answer(await loadReleaseHalves(db, orgDefault.releaseVersion), 'org-default');\n\n  if (canary) {\n    const h = await loadReleaseHalves(db, canary.releaseVersion);\n    const problems = toolchainCandidateProblems(h);\n    if (problems.length === 0) return answer(h, 'canary');\n    // Members fall through to the platform default. Logged, never returned:\n    // the answer must not reveal canary membership.\n    logger.warn('Canary toolchain release fails its guards; serving the platform default', { releaseVersion: canary.releaseVersion, problems });\n  }\n\n  const platform = await currentPlatformDefault(db);\n  if (!platform) {\n    throw new ManagedToolchainError(ErrorCode.TOOLCHAIN_NO_DEFAULT, 'No platform default toolchain release is set. An operator must set one (init-platform does this on a fresh install).');\n  }\n  return answer(await loadReleaseHalves(db, platform), 'default');\n}\n\n/** {@link resolveManagedToolchain} with injected reads and hierarchy (tests). */\nexport async function resolveManagedToolchainWith(\n  deps: ManagedToolchainDeps,\n  caller: ManagedToolchainCaller,\n  opts: { releasePin?: string } = {},\n): Promise<ManagedToolchainResolution> {\n  const self = caller.orgId.toLowerCase();\n  // Walk the hierarchy only when some org has a setting (and outside the transaction).\n  const walk = await deps.read((db) => anyOrgSettings(db));\n  const chain = walk ? await toolchainOrgChain(self, deps.getParent) : [self];\n  return deps.read((db) => resolveOnChain(db, chain, opts.releasePin));\n}\n\n/**\n * Resolve the managed toolchain release for `caller` (see the module doc).\n * Throws {@link ManagedToolchainError}: TOOLCHAIN_NO_DEFAULT (409, no platform\n * default), NOT_FOUND (404, a missing / deleted pin), TOOLCHAIN_PAIR_MISMATCH\n * (500), VALIDATION_ERROR (400, a malformed pin).\n */\nexport function resolveManagedToolchain(caller: ManagedToolchainCaller, opts: { releasePin?: string } = {}): Promise<ManagedToolchainResolution> {\n  return resolveManagedToolchainWith(defaultDeps, caller, opts);\n}\n\n/** {@link isEligibleRelease} with injected reads and hierarchy (tests). */\nexport async function isEligibleReleaseWith(deps: ManagedToolchainDeps, orgId: string, releaseVersion: string): Promise<boolean> {\n  if (!isToolchainReleaseVersion(releaseVersion)) return false;\n  const self = orgId.toLowerCase();\n  const halves = await deps.read((db) => loadReleaseHalves(db, releaseVersion));\n  if (releaseLifecycleProblems(halves).length > 0) return false;\n  if (await deps.read((db) => wasPlatformDefault(db, releaseVersion))) return true;\n  const walk = await deps.read((db) => anyOrgSettings(db));\n  if (!walk) return false;\n  const chain = await toolchainOrgChain(self, deps.getParent);\n  const canary = await deps.read((db) => nearestOnChain(db, schema.toolchainRollout, chain));\n  return canary?.releaseVersion === releaseVersion;\n}\n\n/**\n * D15: whether `orgId` may SET `releaseVersion` as a pipeline pin or its org\n * default — both halves live (active, unyanked, not deprecated) AND either it\n * has been the platform default or it is the caller's canary (nearest\n * membership on its chain).\n */\nexport function isEligibleRelease(orgId: string, releaseVersion: string): Promise<boolean> {\n  return isEligibleReleaseWith(defaultDeps, orgId, releaseVersion);\n}\n\n// -----------------------------------------------------------------------------\n// The org's own picture: the org-default panel and the eligible-release list\n// (docs/plans/bootstrap-image-versioning.md §5, Phase 4, D15)\n// -----------------------------------------------------------------------------\n\n/**\n * What the org-default panel shows a caller about ITS OWN org: never another\n * org's choice, and of the ancestors only which one's default applies.\n */\nexport interface OrgToolchainOverview {\n  /** The caller's chain, own org first (lowercased). */\n  chain: string[];\n  /** What the org's UNPINNED pipelines resolve to now. */\n  effective: { releaseVersion: string; resolvedVia: ToolchainResolvedVia; warnings: ManagedToolchainWarning[] };\n  /** The caller org's own `org_toolchain_default` row, if it set one. */\n  ownDefault: OrgToolchainDefault | null;\n  /** The ancestor whose org default applies, when the org set none of its own. */\n  inheritedFrom: { orgId: string; releaseVersion: string } | null;\n  /** The caller's canary release (its NEAREST membership on the chain), or null. */\n  canaryRelease: string | null;\n  platformDefault: string | null;\n}\n\n/** {@link readOrgToolchainOverview} with injected reads and hierarchy (tests). */\nexport async function readOrgToolchainOverviewWith(deps: ManagedToolchainDeps, orgId: string): Promise<OrgToolchainOverview> {\n  const self = orgId.toLowerCase();\n  const walk = await deps.read((db) => anyOrgSettings(db));\n  const chain = walk ? await toolchainOrgChain(self, deps.getParent) : [self];\n  return deps.read(async (db) => {\n    const rows = await db.select().from(schema.orgToolchainDefault)\n      .where(inArray(sql<string>`lower(${schema.orgToolchainDefault.orgId})`, chain)) as OrgToolchainDefault[];\n    const depthOf = (r: OrgToolchainDefault) => chain.indexOf(r.orgId.toLowerCase());\n    const ownDefault = rows.find((r) => depthOf(r) === 0) ?? null;\n    const nearest = rows.filter((r) => depthOf(r) >= 0).sort((a, b) => depthOf(a) - depthOf(b))[0] ?? null;\n    const [canary, platformDefault, resolution] = await Promise.all([\n      nearestOnChain(db, schema.toolchainRollout, chain),\n      currentPlatformDefault(db),\n      resolveOnChain(db, chain),\n    ]);\n    return {\n      chain,\n      effective: { releaseVersion: resolution.releaseVersion, resolvedVia: resolution.resolvedVia, warnings: resolution.warnings },\n      ownDefault,\n      inheritedFrom: !ownDefault && nearest ? { orgId: nearest.orgId, releaseVersion: nearest.releaseVersion } : null,\n      canaryRelease: canary?.releaseVersion ?? null,\n      platformDefault,\n    };\n  });\n}\n\n/**\n * The caller org's toolchain overview (elevated reads, the same chain walk and\n * precedence as {@link resolveManagedToolchain}). Throws what the resolver\n * throws — TOOLCHAIN_NO_DEFAULT (409) when nothing resolves at all.\n */\nexport function readOrgToolchainOverview(orgId: string): Promise<OrgToolchainOverview> {\n  return readOrgToolchainOverviewWith(defaultDeps, orgId);\n}\n\n/** One release the caller may pin or set (D15), with what the selectors show. */\nexport interface EligibleToolchainRelease {\n  releaseVersion: string;\n  release: ToolchainRelease;\n  bootstrap: Plugin;\n  synth: Plugin;\n  /** THE platform default now. */\n  isPlatformDefault: boolean;\n  /** The caller's canary release (nearest membership). */\n  isCanary: boolean;\n}\n\n/** {@link listEligibleReleases} with injected reads and hierarchy (tests). */\nexport async function listEligibleReleasesWith(deps: ManagedToolchainDeps, orgId: string): Promise<{ platformDefault: string | null; releases: EligibleToolchainRelease[] }> {\n  const self = orgId.toLowerCase();\n  const walk = await deps.read((db) => anyOrgSettings(db));\n  const chain = walk ? await toolchainOrgChain(self, deps.getParent) : [self];\n  return deps.read(async (db) => {\n    const [releases, rows, history, platformDefault, canary] = await Promise.all([\n      db.select().from(schema.toolchainRelease) as Promise<ToolchainRelease[]>,\n      db.select().from(schema.plugin).where(and(\n        eq(schema.plugin.orgId, SYSTEM_ORG_ID),\n        inArray(schema.plugin.name, [...MANAGED_TOOLCHAIN_PLUGINS]),\n        isNull(schema.plugin.deletedAt),\n      )) as Promise<Plugin[]>,\n      db.select({ releaseVersion: schema.toolchainDefaultHistory.releaseVersion }).from(schema.toolchainDefaultHistory) as Promise<Array<{ releaseVersion: string }>>,\n      currentPlatformDefault(db),\n      nearestOnChain(db, schema.toolchainRollout, chain),\n    ]);\n    const promoted = new Set(history.map((h) => h.releaseVersion));\n    if (platformDefault) promoted.add(platformDefault);\n    const out: EligibleToolchainRelease[] = [];\n    for (const release of releases) {\n      const v = release.releaseVersion;\n      const halves: ReleaseHalves = {\n        releaseVersion: v,\n        release,\n        bootstrap: rows.find((p) => p.name === BOOTSTRAP && p.version === v) ?? null,\n        synth: rows.find((p) => p.name === SYNTH && p.version === v) ?? null,\n      };\n      if (!releaseExists(halves) || releaseLifecycleProblems(halves).length > 0) continue;\n      const isCanary = canary?.releaseVersion === v;\n      if (!promoted.has(v) && !isCanary) continue;\n      out.push({ releaseVersion: v, release, bootstrap: halves.bootstrap, synth: halves.synth, isPlatformDefault: platformDefault === v, isCanary });\n    }\n    out.sort((a, b) => compareSemver(b.releaseVersion, a.releaseVersion));\n    return { platformDefault, releases: out };\n  });\n}\n\n/**\n * Every release `orgId` may SET as a pipeline pin or its org default (D15, the\n * same rule as {@link isEligibleRelease}), newest first. Never another org's\n * data: a canary appears only when it is the caller's own (nearest) membership.\n */\nexport function listEligibleReleases(orgId: string): Promise<{ platformDefault: string | null; releases: EligibleToolchainRelease[] }> {\n  return listEligibleReleasesWith(defaultDeps, orgId);\n}\n\n// -----------------------------------------------------------------------------\n// Caller helpers\n// -----------------------------------------------------------------------------\n\n/**\n * Each resolver refusal code's step-resolution refusal (anything else is\n * `toolchain_unresolved`). `details` rides along except for NO_DEFAULT, which\n * carries none worth showing.\n */\nconst REFUSAL_BY_CODE: Partial<Record<ErrorCode, { code: ResolutionRefusal['code']; reason: string; details: boolean }>> = {\n  [ErrorCode.NOT_FOUND]: { code: 'NOT_FOUND', reason: 'toolchain_release_not_found', details: true },\n  [ErrorCode.VALIDATION_ERROR]: { code: 'NOT_FOUND', reason: 'toolchain_release_invalid', details: true },\n  [ErrorCode.TOOLCHAIN_NO_DEFAULT]: { code: 'PLUGIN_UNAVAILABLE', reason: 'toolchain_no_default', details: false },\n};\nconst UNRESOLVED_REFUSAL = { code: 'PLUGIN_UNAVAILABLE', reason: 'toolchain_unresolved', details: true } as const;\n\n/** The resolver's error as the refusal shape step resolution reports (contract check, declared side, facts). */\nexport function managedToolchainRefusal(err: ManagedToolchainError): ResolutionRefusal {\n  const r = REFUSAL_BY_CODE[err.code as ErrorCode] ?? UNRESOLVED_REFUSAL;\n  return { code: r.code, reason: r.reason, message: err.message, ...(r.details && err.details ? { details: err.details } : {}) };\n}\n\n/**\n * Resolve ONE managed half for a step: the plugin row plus the resolution, or\n * the refusal. Any non-resolver error (a database or hierarchy failure)\n * propagates.\n */\nexport async function resolveManagedToolchainHalf(\n  caller: ManagedToolchainCaller,\n  name: ManagedToolchainPlugin,\n  opts: { releasePin?: string } = {},\n): Promise<{ plugin: Plugin; resolution: ManagedToolchainResolution } | { refusal: ResolutionRefusal; error: ManagedToolchainError }> {\n  try {\n    const resolution = await resolveManagedToolchain(caller, opts);\n    return { plugin: name === BOOTSTRAP ? resolution.bootstrap : resolution.synth, resolution };\n  } catch (err) {\n    if (err instanceof ManagedToolchainError) return { refusal: managedToolchainRefusal(err), error: err };\n    throw err;\n  }\n}\n"]}

package/lib/api/public-directory.d.ts

@@ -26,22 +26,11 @@
  * name (typo tolerance), ranked by `ts_rank` + name similarity, blended with the
  * Bayesian rating and install count when present. Paused listings are hidden.
  */
-import { type PublisherTier } from '@pipeline-builder/api-core';
+import type { PublisherTier } from '@pipeline-builder/api-core';
 import type { HealthBreakdown } from '../database/drizzle-schema.js';
-/**
- * DERIVED from api-core's canonical `PUBLISHER_TIERS`, not restated.
- *
- * This was a hand-written copy of the same four values, and the copy is what
- * the public route's zod enum validated — while the view types in the same
- * package already used `PublisherTier`. A fifth tier would have been stored and
- * displayed and then silently unfilterable, because the filter would still only
- * accept the four this list remembered.
- */
-export type DirectoryTrustTier = PublisherTier;
 export type DirectoryIconKind = 'vendor' | 'uploaded' | 'monogram' | 'category';
 export type DirectorySort = 'relevance' | 'rating' | 'installs' | 'updated' | 'name' | 'health';
 export declare const DIRECTORY_SORTS: readonly DirectorySort[];
-export declare const DIRECTORY_TIERS: readonly DirectoryTrustTier[];
 /** Minimum `word_similarity(query, name)` for a fuzzy name match (typo tolerance). */
 export declare const FUZZY_NAME_THRESHOLD = 0.3;
 /** Max query length accepted (longer is truncated, never an error). */
@@ -51,7 +40,7 @@ export declare const DIRECTORY_MAX_LIMIT = 60;
 export interface DirectorySearchParams {
     q?: string;
     category?: string;
-    tier?: DirectoryTrustTier;
+    tier?: PublisherTier;
     license?: string;
     computeType?: string;
     needsSecrets?: boolean;
@@ -64,7 +53,7 @@ export interface DirectoryListingCard {
     publisher: {
         handle: string;
         displayName: string;
-        tier: DirectoryTrustTier;
+        tier: PublisherTier;
     };
     name: string;
     summary: string;
@@ -248,7 +237,7 @@ export interface PublicListingRow {
     id: string;
     publisher_handle: string;
     publisher_display_name: string;
-    publisher_tier: DirectoryTrustTier;
+    publisher_tier: PublisherTier;
     name: string;
     category: string;
     summary: string | null;