@pipeline-builder/pipeline-data 4.1.15 → 4.1.16

package/lib/api/plugin-resolution.js

@@ -0,0 +1,649 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Resolving a plugin reference to an ecosystem LISTING version through the
+ * org's install (docs/plugin-installing.md).
+ *
+ * One implementation shared by every place that answers "which listed version
+ * does this org's reference run?": the plugin service's `/plugins/lookup` (what
+ * synth pins), the pipeline service's contract check at pipeline create, the AI
+ * generator's plugin list and the placeholder guard. The decisions are PURE
+ * functions over loaded rows; the rows come through a {@link ListingDataSource}
+ * so each service can load them its own way ({@link drizzleListingSource} is the
+ * plain drizzle one).
+ *
+ * The model:
+ *  - An org resolves a listing only through an INSTALL: an explicit
+ *    `plugin_installs` row (its own, or — for a team — its root org's), or
+ *    for the Official publisher the IMPLICIT install every org has unless its
+ *    consumption policy says `officialInstalls: explicit`. An explicit
+ *    install overrides the implicit one.
+ *  - The org's CONSUMPTION POLICY is applied at every resolution: allowed
+ *    tiers, blocked listings, advisory blocking; secrets are withheld from tiers
+ *    the policy doesn't trust with them. A team's policy is merged with its root
+ *    org's and can only be stricter.
+ *  - Version choice: the install's range (pinned / `~` / `^` / non-breaking
+ *    latest; implicit = the lowest live major), narrowed by the reference's own
+ *    version spec. Yanked versions never resolve for a listing; a paused
+ *    version is skipped unless the install already resolved to it or the
+ *    reference pins it exactly; advisory-blocked versions are skipped.
+ */
+import { and, eq, inArray } from 'drizzle-orm';
+import { compareSemver, isVersionRange, parseSemver, parseVersionSpec, satisfiesVersionSpec, } from './semver-range.js';
+import { OFFICIAL_PUBLISHER_HANDLE, PUBLISHER_TIERS, schema, } from '../database/drizzle-schema.js';
+/** The defaults (and the column defaults of `plugin_install_policies`). */
+export const DEFAULT_CONSUMPTION_POLICY = Object.freeze({
+    allowedTiers: ['official', 'verified'],
+    requireApprovalTiers: ['community', 'unverified'],
+    secretsAllowedTiers: ['official', 'verified'],
+    blockOnAdvisory: 'critical',
+    officialInstalls: 'implicit',
+    blockedListings: [],
+});
+/** At most this many blocked listings per policy. */
+export const MAX_BLOCKED_LISTINGS = 500;
+const BLOCK_ORDER = ['never', 'critical', 'high'];
+const sortTiers = (tiers) => PUBLISHER_TIERS.filter((t) => new Set(tiers).has(t));
+const listingKey = (r) => `${r.publisher}/${r.name}`;
+function uniqueListings(refs) {
+    const seen = new Map();
+    for (const r of refs)
+        seen.set(listingKey(r), { publisher: r.publisher, name: r.name });
+    return [...seen.values()].sort((a, b) => listingKey(a).localeCompare(listingKey(b)));
+}
+/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */
+export function policyOf(row) {
+    const d = DEFAULT_CONSUMPTION_POLICY;
+    return {
+        allowedTiers: sortTiers(row?.allowedTiers ?? d.allowedTiers),
+        requireApprovalTiers: sortTiers(row?.requireApprovalTiers ?? d.requireApprovalTiers),
+        secretsAllowedTiers: sortTiers(row?.secretsAllowedTiers ?? d.secretsAllowedTiers),
+        blockOnAdvisory: row?.blockOnAdvisory ?? d.blockOnAdvisory,
+        officialInstalls: row?.officialInstalls ?? d.officialInstalls,
+        blockedListings: uniqueListings(row?.blockedListings ?? d.blockedListings),
+    };
+}
+/**
+ * A team's policy under its root org's: each field takes the STRICTER of
+ * the two, so a team can narrow what its root allows but never widen it.
+ */
+export function mergeConsumptionPolicies(root, team) {
+    const intersect = (a, b) => sortTiers(a.filter((t) => b.includes(t)));
+    const union = (a, b) => sortTiers([...a, ...b]);
+    const stricterBlock = BLOCK_ORDER.indexOf(root.blockOnAdvisory) >= BLOCK_ORDER.indexOf(team.blockOnAdvisory)
+        ? root.blockOnAdvisory : team.blockOnAdvisory;
+    return {
+        allowedTiers: intersect(root.allowedTiers, team.allowedTiers),
+        requireApprovalTiers: union(root.requireApprovalTiers, team.requireApprovalTiers),
+        secretsAllowedTiers: intersect(root.secretsAllowedTiers, team.secretsAllowedTiers),
+        blockOnAdvisory: stricterBlock,
+        officialInstalls: root.officialInstalls === 'explicit' || team.officialInstalls === 'explicit' ? 'explicit' : 'implicit',
+        blockedListings: uniqueListings([...root.blockedListings, ...team.blockedListings]),
+    };
+}
+/**
+ * The policy an org's resolution runs under. A root org: its own row (or the
+ * defaults). A team (`rootOrgId` set): its root's policy, merged with the
+ * team's own row when it has one.
+ */
+export function effectiveConsumptionPolicy(rows, orgId, rootOrgId) {
+    const own = rows.find((r) => r.orgId === orgId) ?? null;
+    if (!rootOrgId || rootOrgId === orgId)
+        return policyOf(own);
+    const root = policyOf(rows.find((r) => r.orgId === rootOrgId) ?? null);
+    return own ? mergeConsumptionPolicies(root, policyOf(own)) : root;
+}
+const HANDLE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
+function tierList(v, field) {
+    if (!Array.isArray(v))
+        return `${field} must be an array of tiers`;
+    const bad = v.filter((t) => !PUBLISHER_TIERS.includes(t));
+    if (bad.length)
+        return `${field} has unknown tiers: ${bad.map(String).join(', ')}`;
+    return sortTiers(v);
+}
+/**
+ * Validate a (partial) policy update over `base`. Returns the full new policy,
+ * or an error message. `blockedListings` entries are `{ publisher, name }` or
+ * `"publisher/name"`.
+ */
+export function applyPolicyUpdate(base, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return 'body must be an object';
+    const b = input;
+    const next = { ...base };
+    for (const field of ['allowedTiers', 'requireApprovalTiers', 'secretsAllowedTiers']) {
+        if (b[field] === undefined)
+            continue;
+        const tiers = tierList(b[field], field);
+        if (typeof tiers === 'string')
+            return tiers;
+        next[field] = tiers;
+    }
+    if (b.blockOnAdvisory !== undefined) {
+        if (!BLOCK_ORDER.includes(b.blockOnAdvisory))
+            return 'blockOnAdvisory must be critical, high or never';
+        next.blockOnAdvisory = b.blockOnAdvisory;
+    }
+    if (b.officialInstalls !== undefined) {
+        if (b.officialInstalls !== 'implicit' && b.officialInstalls !== 'explicit')
+            return 'officialInstalls must be implicit or explicit';
+        next.officialInstalls = b.officialInstalls;
+    }
+    if (b.blockedListings !== undefined) {
+        if (!Array.isArray(b.blockedListings))
+            return 'blockedListings must be an array';
+        if (b.blockedListings.length > MAX_BLOCKED_LISTINGS)
+            return `at most ${MAX_BLOCKED_LISTINGS} blocked listings`;
+        const refs = [];
+        for (const raw of b.blockedListings) {
+            const ref = typeof raw === 'string'
+                ? (() => { const [publisher, name, extra] = raw.split('/'); return extra === undefined ? { publisher, name } : null; })()
+                : raw && typeof raw === 'object' ? { publisher: raw.publisher, name: raw.name } : null;
+            if (!ref || typeof ref.publisher !== 'string' || typeof ref.name !== 'string'
+                || !HANDLE_RE.test(ref.publisher) || !NAME_RE.test(ref.name)) {
+                return 'each blocked listing must be { publisher, name } (or "publisher/name")';
+            }
+            refs.push({ publisher: ref.publisher, name: ref.name });
+        }
+        next.blockedListings = uniqueListings(refs);
+    }
+    return next;
+}
+/** Whether `policy` (or the listing's own state) refuses the listing outright. */
+export function listingBlock(policy, publisher, listing) {
+    const ref = `${publisher.handle}/${listing.name}`;
+    if (publisher.suspendedAt || listing.state === 'suspended' || listing.state === 'transferred') {
+        return { reason: 'suspended', message: `${ref} is ${listing.state === 'transferred' ? 'transferred' : 'suspended'} and no longer resolves.` };
+    }
+    if (policy.blockedListings.some((b) => b.publisher === publisher.handle && b.name === listing.name)) {
+        return { reason: 'blocked_listing', message: `Your organization's plugin policy blocks ${ref}.` };
+    }
+    if (!policy.allowedTiers.includes(publisher.tier)) {
+        return { reason: 'tier', message: `Your organization's plugin policy doesn't allow ${publisher.tier} plugins (${ref}).` };
+    }
+    return null;
+}
+/** The refusal a {@link ListingBlock} becomes. */
+export function blockRefusal(block) {
+    return block.reason === 'suspended'
+        ? { code: 'PLUGIN_UNAVAILABLE', reason: 'suspended', message: block.message }
+        : { code: 'PLUGIN_BLOCKED_BY_POLICY', reason: block.reason, message: block.message };
+}
+// -----------------------------------------------------------------------------
+// Advisories
+// -----------------------------------------------------------------------------
+/** Severities each `blockOnAdvisory` setting blocks. */
+export const ADVISORY_BLOCK_SEVERITIES = {
+    critical: ['critical'],
+    high: ['critical', 'high'],
+    never: [],
+};
+const COMPARATOR = /^(>=|<=|>|<|=)?\s*v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/;
+/** One comparator set (`>=1.0.0 <1.2.3`, `^1.2`, `1.x`, `1.0.0 - 1.2.0`) against `version`. */
+function comparatorSetCovers(set, version) {
+    const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(set);
+    if (hyphen)
+        return compareSemver(version, hyphen[1]) >= 0 && compareSemver(version, hyphen[2]) <= 0;
+    const parts = set.split(/\s+/).filter(Boolean);
+    if (parts.length === 1 && parseVersionSpec(parts[0]))
+        return satisfiesVersionSpec(version, parts[0]);
+    return parts.every((p) => {
+        const m = COMPARATOR.exec(p);
+        if (!m)
+            return false;
+        const c = compareSemver(version, m[2]);
+        switch (m[1] ?? '=') {
+            case '>=': return c >= 0;
+            case '<=': return c <= 0;
+            case '>': return c > 0;
+            case '<': return c < 0;
+            default: return c === 0;
+        }
+    });
+}
+/**
+ * Whether an advisory's `affectedRange` covers `version`: `||`-separated
+ * comparator sets, each either the lookup spec forms (`^`, `~`, partial,
+ * exact) or space-separated comparators (`>=1.0.0 <1.2.3`) or a hyphen range.
+ * `*` covers everything; an unparseable range covers nothing.
+ */
+export function advisoryRangeCovers(range, version) {
+    if (!parseSemver(version))
+        return false;
+    return range.split('||').map((s) => s.trim()).some((set) => set === '*' || (set !== '' && comparatorSetCovers(set, version)));
+}
+/**
+ * Why `range` isn't a usable advisory range (the forms {@link advisoryRangeCovers}
+ * understands), or null when it is. An advisory whose range parses as nothing
+ * would silently cover nothing, so drafts are refused instead.
+ */
+export function advisoryRangeProblem(range) {
+    const trimmed = range.trim();
+    if (trimmed === '')
+        return 'the affected range is empty';
+    if (trimmed.length > 255)
+        return 'the affected range is longer than 255 characters';
+    for (const set of trimmed.split('||').map((x) => x.trim())) {
+        if (set === '*')
+            continue;
+        if (set === '')
+            return 'the affected range has an empty "||" alternative';
+        const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(set);
+        if (hyphen) {
+            if (!parseSemver(hyphen[1]) || !parseSemver(hyphen[2]))
+                return `"${set}" is not a valid hyphen range`;
+            continue;
+        }
+        const parts = set.split(/\s+/).filter(Boolean);
+        if (parts.length === 1 && parts[0] !== 'latest' && parseVersionSpec(parts[0]))
+            continue;
+        const bad = parts.find((x) => !COMPARATOR.test(x));
+        if (bad !== undefined)
+            return `"${bad}" is not a version, a ^/~ range or a comparator (>=, <=, >, <, =)`;
+    }
+    return null;
+}
+/** The PUBLISHED advisories whose range covers `version` (any severity), most severe first. */
+export function advisoriesCovering(advisories, version) {
+    const rank = { critical: 0, high: 1, medium: 2, low: 3 };
+    return advisories
+        .filter((a) => a.state === 'published' && advisoryRangeCovers(a.affectedRange, version))
+        .sort((a, b) => rank[a.severity] - rank[b.severity]);
+}
+/** The PUBLISHED advisories the policy blocks `version` for. */
+export function blockingAdvisories(advisories, version, policy) {
+    const severities = ADVISORY_BLOCK_SEVERITIES[policy.blockOnAdvisory];
+    if (severities.length === 0)
+        return [];
+    return advisories.filter((a) => a.state === 'published' && severities.includes(a.severity) && advisoryRangeCovers(a.affectedRange, version));
+}
+const isStable = (v) => (parseSemver(v)?.prerelease.length ?? 1) === 0;
+/**
+ * The implicit Official install's range: every version of the LOWEST live
+ * major (`<major>.x`) — patch and minor versions flow, a new major never does
+ * (the org moves to it with an explicit install). Null when nothing is live.
+ */
+export function implicitInstallRange(versions) {
+    const majors = versions
+        .filter((v) => !v.yankedAt && isStable(v.version))
+        .map((v) => parseSemver(v.version).major);
+    if (majors.length === 0)
+        return null;
+    return `${Math.min(...majors)}.x`;
+}
+/** Whether an install's version policy admits `version` (the baseline is `pinnedVersion`). */
+export function installAdmits(install, version, versions) {
+    const base = install.pinnedVersion;
+    switch (install.versionPolicy) {
+        case 'pinned':
+            return version === base;
+        case 'patch':
+            return base !== null && satisfiesVersionSpec(version, `~${base}`);
+        case 'minor':
+            return base !== null && satisfiesVersionSpec(version, `^${base}`);
+        case 'latest': {
+            if (!isStable(version))
+                return false;
+            if (base === null)
+                return true;
+            if (compareSemver(version, base) < 0)
+                return false;
+            // Never cross a version the publisher marked breaking.
+            return !versions.some((v) => v.breaking && compareSemver(v.version, base) > 0 && compareSemver(v.version, version) <= 0);
+        }
+        default:
+            return false;
+    }
+}
+/** Whether `mode` admits `version` (the implicit range for an implicit install). */
+export function modeAdmits(mode, version, versions) {
+    if (mode.kind === 'explicit')
+        return installAdmits(mode.install, version, versions);
+    const range = implicitInstallRange(versions);
+    return range !== null && satisfiesVersionSpec(version, range);
+}
+/**
+ * Pick the listed version a reference resolves to (see the module doc), or
+ * the refusal that explains why none can.
+ */
+export function selectListingVersion(input) {
+    const { ref, versions, mode, requested, advisories, policy } = input;
+    const exact = requested !== undefined && !isVersionRange(requested) ? requested.trim() : null;
+    if (exact !== null) {
+        const v = versions.find((x) => x.version === exact);
+        if (!v)
+            return { refusal: { code: 'NOT_FOUND', reason: 'version_not_found', message: `${ref} has no published version ${exact}.` } };
+        if (v.yankedAt) {
+            return {
+                refusal: {
+                    code: 'PLUGIN_UNAVAILABLE',
+                    reason: 'yanked',
+                    message: `${ref}@${exact} is yanked${v.yankReason ? `: ${v.yankReason}` : ''}. Move to a supported version.`,
+                    details: { version: exact },
+                },
+            };
+        }
+        if (mode.kind === 'explicit' && !installAdmits(mode.install, exact, versions)) {
+            return {
+                refusal: {
+                    code: 'PLUGIN_NOT_INSTALLED',
+                    reason: 'version_outside_install',
+                    message: `${ref}@${exact} is outside your install (${mode.install.versionPolicy} from ${mode.install.pinnedVersion}). Upgrade the install first.`,
+                    details: { version: exact, versionPolicy: mode.install.versionPolicy, pinnedVersion: mode.install.pinnedVersion },
+                },
+            };
+        }
+        const blocking = blockingAdvisories(advisories, exact, policy);
+        if (blocking.length)
+            return { refusal: advisoryRefusal(ref, exact, blocking) };
+        return { version: v };
+    }
+    const resolvedBefore = mode.kind === 'explicit' ? mode.install.resolvedVersion : null;
+    // The range the INSTALL allows. For the implicit install an explicit spec on
+    // the reference replaces the implicit range (it is a deliberate choice).
+    const admitted = versions.filter((v) => !v.yankedAt
+        && (mode.kind === 'explicit' ? installAdmits(mode.install, v.version, versions)
+            : requested !== undefined || modeAdmits(mode, v.version, versions))
+        && (requested === undefined || satisfiesVersionSpec(v.version, requested))
+        && (!v.pausedAt || v.version === resolvedBefore));
+    const allowed = admitted.filter((v) => blockingAdvisories(advisories, v.version, policy).length === 0);
+    // Ranges only admit prereleases they name (npm semantics), so the highest
+    // admitted version is the answer.
+    const best = highest(allowed.map((v) => v.version));
+    if (best)
+        return { version: allowed.find((v) => v.version === best) };
+    if (admitted.length > 0) {
+        const newest = highest(admitted.map((v) => v.version));
+        return { refusal: advisoryRefusal(ref, newest, blockingAdvisories(advisories, newest, policy)) };
+    }
+    if (mode.kind === 'explicit' && requested !== undefined
+        && versions.some((v) => !v.yankedAt && satisfiesVersionSpec(v.version, requested))) {
+        return {
+            refusal: {
+                code: 'PLUGIN_NOT_INSTALLED',
+                reason: 'version_outside_install',
+                message: `No version of ${ref} matching ${requested} is inside your install (${mode.install.versionPolicy} from ${mode.install.pinnedVersion}). Upgrade the install first.`,
+                details: { requested, versionPolicy: mode.install.versionPolicy, pinnedVersion: mode.install.pinnedVersion },
+            },
+        };
+    }
+    return {
+        refusal: {
+            code: 'NOT_FOUND',
+            reason: 'no_matching_version',
+            message: `No resolvable version of ${ref}${requested ? ` matches ${requested}` : ''}.`,
+        },
+    };
+}
+/** The highest of `versions` by semver (prereleases included). */
+function highest(versions) {
+    return versions.reduce((best, v) => (best === null || compareSemver(v, best) > 0 ? v : best), null);
+}
+function advisoryRefusal(ref, version, blocking) {
+    const fixed = blocking.map((a) => a.fixedVersion).filter((v) => !!v);
+    return {
+        code: 'PLUGIN_BLOCKED_BY_POLICY',
+        reason: 'advisory',
+        message: `${ref}@${version} is blocked by your organization's advisory policy: ${blocking.map((a) => `${a.severity} — ${a.summary}`).join('; ')}.`
+            + (fixed.length ? ` Fixed in ${fixed.join(', ')}.` : ''),
+        details: { version, advisories: blocking.map((a) => a.id), ...(fixed.length ? { fixedVersions: fixed } : {}) },
+    };
+}
+/** The org ids whose installs and policies apply, own first. */
+export function scopeOrgIds(scope) {
+    const own = scope.orgId.toLowerCase();
+    const root = scope.rootOrgId?.toLowerCase();
+    return root && root !== own ? [own, root] : [own];
+}
+/**
+ * How the org reaches `listing` — or the refusal. An ACTIVE own-org row wins,
+ * then the root org's (a team inherits it); failing both, the implicit
+ * Official install (unless the policy is `explicit`); otherwise the org's own
+ * pending / denied row explains the refusal.
+ */
+export function installModeFor(publisher, listing, installs, policy, scope) {
+    const [own, root] = scopeOrgIds(scope);
+    const forListing = installs.filter((i) => i.listingId === listing.id);
+    const ownRow = forListing.find((i) => i.orgId.toLowerCase() === own);
+    const rootRow = root ? forListing.find((i) => i.orgId.toLowerCase() === root) : undefined;
+    if (ownRow?.status === 'active')
+        return { kind: 'explicit', install: ownRow, inherited: false };
+    if (rootRow?.status === 'active')
+        return { kind: 'explicit', install: rootRow, inherited: true };
+    const ref = `${publisher.handle}/${listing.name}`;
+    if (publisher.handle === OFFICIAL_PUBLISHER_HANDLE) {
+        if (policy.officialInstalls === 'implicit')
+            return { kind: 'implicit' };
+        if (!ownRow) {
+            return {
+                code: 'PLUGIN_NOT_INSTALLED',
+                reason: 'official_explicit',
+                message: `Your organization installs Official plugins explicitly; install ${ref} first.`,
+            };
+        }
+    }
+    if (ownRow?.status === 'pending_approval') {
+        return { code: 'PLUGIN_NOT_INSTALLED', reason: 'pending_approval', message: `The install of ${ref} is waiting for approval.` };
+    }
+    if (ownRow?.status === 'denied') {
+        return { code: 'PLUGIN_NOT_INSTALLED', reason: 'denied', message: `The install of ${ref} was denied.` };
+    }
+    return { code: 'PLUGIN_NOT_INSTALLED', reason: 'not_installed', message: `${ref} is not installed in your organization.` };
+}
+/**
+ * A {@link ListingDataSource} over a drizzle transaction. The caller owns the
+ * transaction's scope: it must be able to read the ecosystem tables (app-role
+ * RLS) and the install rows of the org AND its root org (a team's reads of its
+ * root's rows need an elevated scope, like parent-org plugin reads).
+ */
+export function drizzleListingSource(tx) {
+    const db = tx;
+    const P = schema.publisher;
+    const L = schema.pluginListing;
+    const V = schema.pluginListingVersion;
+    const A = schema.pluginAdvisory;
+    const I = schema.pluginInstall;
+    const IP = schema.pluginInstallPolicy;
+    return {
+        publisherByHandle: async (handle) => (await db.select().from(P).where(eq(P.handle, handle)))[0] ?? null,
+        publishersByIds: async (ids) => (ids.length ? db.select().from(P).where(inArray(P.id, ids)) : []),
+        listingByName: async (publisherId, name) => (await db.select().from(L).where(and(eq(L.publisherId, publisherId), eq(L.name, name))))[0] ?? null,
+        liveListings: async (filter = {}) => {
+            if (filter.ids && filter.ids.length === 0)
+                return [];
+            if (filter.names && filter.names.length === 0)
+                return [];
+            return db.select().from(L).where(and(inArray(L.state, ['listed', 'unmaintained']), ...(filter.ids ? [inArray(L.id, filter.ids)] : []), ...(filter.names ? [inArray(L.name, filter.names)] : [])));
+        },
+        versionsForListings: async (ids) => (ids.length ? db.select().from(V).where(inArray(V.listingId, ids)) : []),
+        advisoriesForListings: async (ids) => (ids.length ? db.select().from(A).where(and(inArray(A.listingId, ids), eq(A.state, 'published'))) : []),
+        installsForOrgs: async (orgIds) => (orgIds.length ? db.select().from(I).where(inArray(I.orgId, orgIds)) : []),
+        policiesForOrgs: async (orgIds) => (orgIds.length ? db.select().from(IP).where(inArray(IP.orgId, orgIds)) : []),
+    };
+}
+/**
+ * Resolve `ref` to a listed version for `scope`, or refuse. Null when the
+ * listing doesn't exist at all (an unqualified reference then simply has no
+ * Official fallback).
+ */
+export async function resolveListingReference(source, ref, scope) {
+    const handle = ref.publisher ?? OFFICIAL_PUBLISHER_HANDLE;
+    const publisher = await source.publisherByHandle(handle);
+    if (!publisher)
+        return null;
+    const listing = await source.listingByName(publisher.id, ref.name);
+    if (!listing)
+        return null;
+    const orgIds = scopeOrgIds(scope);
+    const [policies, installs] = await Promise.all([source.policiesForOrgs(orgIds), source.installsForOrgs(orgIds)]);
+    const policy = effectiveConsumptionPolicy(policies, orgIds[0], orgIds[1]);
+    const block = listingBlock(policy, publisher, listing);
+    if (block)
+        return { ok: false, refusal: blockRefusal(block), publisher, listing };
+    const mode = installModeFor(publisher, listing, installs, policy, scope);
+    if ('code' in mode)
+        return { ok: false, refusal: mode, publisher, listing };
+    const [versions, advisories] = await Promise.all([
+        source.versionsForListings([listing.id]),
+        source.advisoriesForListings([listing.id]),
+    ]);
+    const ref_ = `${publisher.handle}/${listing.name}`;
+    const choice = selectListingVersion({ ref: ref_, versions, mode, requested: ref.version, advisories, policy });
+    if ('refusal' in choice)
+        return { ok: false, refusal: choice.refusal, publisher, listing };
+    const version = choice.version;
+    const { warnings, secretsWithheld } = listedVersionWarnings({ publisher, listing, version, advisories, policy });
+    return { ok: true, publisher, listing, version, mode, policy, secretsWithheld, warnings };
+}
+/**
+ * The non-fatal notes a resolved listed version carries (lookup answers,
+ * synth prints them, the installs view shows them): an unmaintained listing, a
+ * deprecated version, a PUBLISHED advisory covering the version that the org's
+ * `blockOnAdvisory` doesn't block (a blocking one refuses resolution instead),
+ * and withheld secrets.
+ */
+export function listedVersionWarnings(input) {
+    const { publisher, listing, version, advisories, policy } = input;
+    const ref = `${publisher.handle}/${listing.name}`;
+    const declaresSecrets = (version.specSnapshot?.secrets ?? []).length > 0;
+    const secretsWithheld = declaresSecrets && !policy.secretsAllowedTiers.includes(publisher.tier);
+    const warnings = [];
+    if (listing.state === 'unmaintained') {
+        warnings.push({ code: 'LISTING_UNMAINTAINED', message: `${ref} is unmaintained: it receives no updates. Plan a replacement.` });
+    }
+    if (version.deprecatedAt) {
+        warnings.push({ code: 'PLUGIN_DEPRECATED', message: `${ref}@${version.version} is deprecated${version.deprecationMessage ? `: ${version.deprecationMessage}` : ''}.` });
+    }
+    for (const a of advisoriesCovering(advisories, version.version)) {
+        warnings.push({
+            code: 'PLUGIN_ADVISORY',
+            message: `${ref}@${version.version} is affected by a ${a.severity} security advisory: ${a.summary}`
+                + `${a.fixedVersion ? ` Fixed in ${a.fixedVersion}.` : ''}`,
+        });
+    }
+    if (secretsWithheld) {
+        warnings.push({ code: 'PLUGIN_SECRETS_WITHHELD', message: `${ref} is a ${publisher.tier} plugin; your organization's policy gives it no secrets, so its declared secrets are not injected.` });
+    }
+    return { warnings, secretsWithheld };
+}
+/**
+ * The plugin record a resolved listing version runs as — the shape synth and
+ * the contract check read (a `plugins` row's run fields), built from the
+ * version's frozen spec snapshot. `id` is the LISTING VERSION's id (the step
+ * manifest resolves it back), `imageRepository` its `public/*` copy.
+ */
+export function listedPluginRecord(res) {
+    const { publisher, listing, version, mode } = res;
+    const s = (version.specSnapshot ?? {});
+    const arr = (v) => (Array.isArray(v) ? v : []);
+    const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+    return {
+        id: version.id,
+        source: 'listing',
+        publisher: publisher.handle,
+        publisherTier: publisher.tier,
+        listingId: listing.id,
+        install: mode.kind,
+        name: listing.name,
+        version: version.version,
+        imageRepository: version.imageRepository,
+        imageDigest: version.imageDigest,
+        buildType: typeof s.buildType === 'string' ? s.buildType : (version.imageDigest ? 'build_image' : 'metadata_only'),
+        pluginType: s.pluginType ?? 'CodeBuildStep',
+        computeType: s.computeType ?? 'SMALL',
+        description: s.description ?? listing.description ?? null,
+        summary: s.summary ?? listing.summary ?? null,
+        displayName: s.displayName ?? null,
+        keywords: arr(s.keywords),
+        category: s.category ?? listing.category,
+        metadata: obj(s.metadata),
+        env: obj(s.env),
+        buildArgs: {},
+        installCommands: arr(s.installCommands),
+        commands: arr(s.commands),
+        timeout: s.timeout ?? null,
+        failureBehavior: s.failureBehavior ?? 'fail',
+        primaryOutputDirectory: s.primaryOutputDirectory ?? null,
+        secrets: res.secretsWithheld ? [] : arr(s.secrets),
+        requiredMetadata: arr(s.requiredMetadata),
+        requiredVars: arr(s.requiredVars),
+        metadataTypes: obj(s.metadataTypes),
+        varsTypes: obj(s.varsTypes),
+        networkEgress: arr(s.networkEgress),
+        runAsRoot: s.runAsRoot ?? null,
+        license: s.license ?? listing.license ?? null,
+        homepageUrl: s.homepageUrl ?? listing.homepageUrl ?? null,
+        sourceUrl: s.sourceUrl ?? listing.sourceUrl ?? null,
+        documentationUrl: s.documentationUrl ?? null,
+        icon: s.icon ?? listing.icon ?? null,
+        changelog: version.changelog,
+        breaking: version.breaking,
+        vulnCritical: version.vulnCritical,
+        vulnHigh: version.vulnHigh,
+        scannedAt: version.scannedAt,
+        lifecycle: version.deprecatedAt ? 'deprecated' : 'production',
+        deprecatedAt: version.deprecatedAt,
+        deprecationMessage: version.deprecationMessage,
+        yankedAt: null,
+        yankReason: null,
+        visibility: 'public',
+        isDefault: true,
+        isActive: true,
+    };
+}
+/** Load the org's policy and install rows. */
+export async function loadOrgInstallContext(source, scope) {
+    const orgIds = scopeOrgIds(scope);
+    const [policies, installs] = await Promise.all([source.policiesForOrgs(orgIds), source.installsForOrgs(orgIds)]);
+    return { policy: effectiveConsumptionPolicy(policies, orgIds[0], orgIds[1]), installs, scope };
+}
+/**
+ * The org's standing on every live listing (or only `filter`'s). Used by the
+ * in-app catalog; {@link resolvableListings} narrows it to what resolves.
+ */
+export async function orgListingStates(source, scope, filter = {}, ctx) {
+    const context = ctx ?? await loadOrgInstallContext(source, scope);
+    const live = await source.liveListings(filter);
+    if (live.length === 0)
+        return [];
+    const ids = live.map((l) => l.id);
+    const [pubs, versions, advisories] = await Promise.all([
+        source.publishersByIds([...new Set(live.map((l) => l.publisherId))]),
+        source.versionsForListings(ids),
+        source.advisoriesForListings(ids),
+    ]);
+    const byPublisher = new Map(pubs.map((p) => [p.id, p]));
+    const own = scopeOrgIds(scope)[0];
+    const out = [];
+    for (const listing of live) {
+        const publisher = byPublisher.get(listing.publisherId);
+        if (!publisher)
+            continue;
+        const vs = versions.filter((v) => v.listingId === listing.id);
+        const block = listingBlock(context.policy, publisher, listing);
+        const mode = installModeFor(publisher, listing, context.installs, context.policy, scope);
+        const listingAdvisories = advisories.filter((a) => a.listingId === listing.id);
+        let resolved = null;
+        let refusal = null;
+        if (!block && !('code' in mode)) {
+            const choice = selectListingVersion({
+                ref: `${publisher.handle}/${listing.name}`, versions: vs, mode, advisories: listingAdvisories, policy: context.policy,
+            });
+            if ('version' in choice)
+                resolved = choice.version;
+            else
+                refusal = choice.refusal;
+        }
+        const ownInstall = context.installs.find((i) => i.listingId === listing.id && i.orgId.toLowerCase() === own) ?? null;
+        out.push({ publisher, listing, versions: vs, mode, block, resolved, refusal, advisories: listingAdvisories, ownInstall, policy: context.policy });
+    }
+    return out;
+}
+/** The listings an org's references resolve to now (installed or implicit, not blocked). */
+export async function resolvableListings(source, scope, filter = {}) {
+    return (await orgListingStates(source, scope, filter))
+        .filter((s) => s.resolved !== null);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-resolution.js","sourceRoot":"","sources":["../../src/api/plugin-resolution.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Resolving a plugin reference to an ecosystem LISTING version through the\n * org's install (docs/plugin-installing.md).\n *\n * One implementation shared by every place that answers \"which listed version\n * does this org's reference run?\": the plugin service's `/plugins/lookup` (what\n * synth pins), the pipeline service's contract check at pipeline create, the AI\n * generator's plugin list and the placeholder guard. The decisions are PURE\n * functions over loaded rows; the rows come through a {@link ListingDataSource}\n * so each service can load them its own way ({@link drizzleListingSource} is the\n * plain drizzle one).\n *\n * The model:\n *  - An org resolves a listing only through an INSTALL: an explicit\n *    `plugin_installs` row (its own, or — for a team — its root org's), or\n *    for the Official publisher the IMPLICIT install every org has unless its\n *    consumption policy says `officialInstalls: explicit`. An explicit\n *    install overrides the implicit one.\n *  - The org's CONSUMPTION POLICY is applied at every resolution: allowed\n *    tiers, blocked listings, advisory blocking; secrets are withheld from tiers\n *    the policy doesn't trust with them. A team's policy is merged with its root\n *    org's and can only be stricter.\n *  - Version choice: the install's range (pinned / `~` / `^` / non-breaking\n *    latest; implicit = the lowest live major), narrowed by the reference's own\n *    version spec. Yanked versions never resolve for a listing; a paused\n *    version is skipped unless the install already resolved to it or the\n *    reference pins it exactly; advisory-blocked versions are skipped.\n */\n\nimport { and, eq, inArray } from 'drizzle-orm';\nimport type { CrudTx } from './crud-service.js';\nimport {\n  compareSemver, isVersionRange, parseSemver, parseVersionSpec, satisfiesVersionSpec,\n} from './semver-range.js';\nimport {\n  OFFICIAL_PUBLISHER_HANDLE,\n  PUBLISHER_TIERS,\n  schema,\n  type AdvisorySeverity,\n  type BlockedListingRef,\n  type BlockOnAdvisory,\n  type InstallVersionPolicy,\n  type OfficialInstalls,\n  type PluginAdvisory,\n  type PluginInstall,\n  type PluginInstallPolicy,\n  type PluginListing,\n  type PluginListingVersion,\n  type Publisher,\n  type PublisherTier,\n} from '../database/drizzle-schema.js';\n\n// -----------------------------------------------------------------------------\n// Consumption policy\n// -----------------------------------------------------------------------------\n\n/** An org's consumption policy, as the resolver applies it. */\nexport interface ConsumptionPolicy {\n  allowedTiers: PublisherTier[];\n  requireApprovalTiers: PublisherTier[];\n  secretsAllowedTiers: PublisherTier[];\n  blockOnAdvisory: BlockOnAdvisory;\n  officialInstalls: OfficialInstalls;\n  blockedListings: BlockedListingRef[];\n}\n\n/** The defaults (and the column defaults of `plugin_install_policies`). */\nexport const DEFAULT_CONSUMPTION_POLICY: Readonly<ConsumptionPolicy> = Object.freeze<ConsumptionPolicy>({\n  allowedTiers: ['official', 'verified'],\n  requireApprovalTiers: ['community', 'unverified'],\n  secretsAllowedTiers: ['official', 'verified'],\n  blockOnAdvisory: 'critical',\n  officialInstalls: 'implicit',\n  blockedListings: [],\n});\n\n/** At most this many blocked listings per policy. */\nexport const MAX_BLOCKED_LISTINGS = 500;\n\nconst BLOCK_ORDER: readonly BlockOnAdvisory[] = ['never', 'critical', 'high'];\n\nconst sortTiers = (tiers: Iterable<PublisherTier>): PublisherTier[] =>\n  PUBLISHER_TIERS.filter((t) => new Set(tiers).has(t));\n\nconst listingKey = (r: BlockedListingRef): string => `${r.publisher}/${r.name}`;\n\nfunction uniqueListings(refs: readonly BlockedListingRef[]): BlockedListingRef[] {\n  const seen = new Map<string, BlockedListingRef>();\n  for (const r of refs) seen.set(listingKey(r), { publisher: r.publisher, name: r.name });\n  return [...seen.values()].sort((a, b) => listingKey(a).localeCompare(listingKey(b)));\n}\n\n/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */\nexport function policyOf(row: Partial<PluginInstallPolicy> | null | undefined): ConsumptionPolicy {\n  const d = DEFAULT_CONSUMPTION_POLICY;\n  return {\n    allowedTiers: sortTiers(row?.allowedTiers ?? d.allowedTiers),\n    requireApprovalTiers: sortTiers(row?.requireApprovalTiers ?? d.requireApprovalTiers),\n    secretsAllowedTiers: sortTiers(row?.secretsAllowedTiers ?? d.secretsAllowedTiers),\n    blockOnAdvisory: row?.blockOnAdvisory ?? d.blockOnAdvisory,\n    officialInstalls: row?.officialInstalls ?? d.officialInstalls,\n    blockedListings: uniqueListings(row?.blockedListings ?? d.blockedListings),\n  };\n}\n\n/**\n * A team's policy under its root org's: each field takes the STRICTER of\n * the two, so a team can narrow what its root allows but never widen it.\n */\nexport function mergeConsumptionPolicies(root: ConsumptionPolicy, team: ConsumptionPolicy): ConsumptionPolicy {\n  const intersect = (a: PublisherTier[], b: PublisherTier[]) => sortTiers(a.filter((t) => b.includes(t)));\n  const union = (a: PublisherTier[], b: PublisherTier[]) => sortTiers([...a, ...b]);\n  const stricterBlock = BLOCK_ORDER.indexOf(root.blockOnAdvisory) >= BLOCK_ORDER.indexOf(team.blockOnAdvisory)\n    ? root.blockOnAdvisory : team.blockOnAdvisory;\n  return {\n    allowedTiers: intersect(root.allowedTiers, team.allowedTiers),\n    requireApprovalTiers: union(root.requireApprovalTiers, team.requireApprovalTiers),\n    secretsAllowedTiers: intersect(root.secretsAllowedTiers, team.secretsAllowedTiers),\n    blockOnAdvisory: stricterBlock,\n    officialInstalls: root.officialInstalls === 'explicit' || team.officialInstalls === 'explicit' ? 'explicit' : 'implicit',\n    blockedListings: uniqueListings([...root.blockedListings, ...team.blockedListings]),\n  };\n}\n\n/**\n * The policy an org's resolution runs under. A root org: its own row (or the\n * defaults). A team (`rootOrgId` set): its root's policy, merged with the\n * team's own row when it has one.\n */\nexport function effectiveConsumptionPolicy(\n  rows: ReadonlyArray<Partial<PluginInstallPolicy> & { orgId?: string }>,\n  orgId: string,\n  rootOrgId?: string,\n): ConsumptionPolicy {\n  const own = rows.find((r) => r.orgId === orgId) ?? null;\n  if (!rootOrgId || rootOrgId === orgId) return policyOf(own);\n  const root = policyOf(rows.find((r) => r.orgId === rootOrgId) ?? null);\n  return own ? mergeConsumptionPolicies(root, policyOf(own)) : root;\n}\n\nconst HANDLE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\nconst NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;\n\nfunction tierList(v: unknown, field: string): PublisherTier[] | string {\n  if (!Array.isArray(v)) return `${field} must be an array of tiers`;\n  const bad = v.filter((t) => !(PUBLISHER_TIERS as readonly unknown[]).includes(t));\n  if (bad.length) return `${field} has unknown tiers: ${bad.map(String).join(', ')}`;\n  return sortTiers(v as PublisherTier[]);\n}\n\n/**\n * Validate a (partial) policy update over `base`. Returns the full new policy,\n * or an error message. `blockedListings` entries are `{ publisher, name }` or\n * `\"publisher/name\"`.\n */\nexport function applyPolicyUpdate(base: ConsumptionPolicy, input: unknown): ConsumptionPolicy | string {\n  if (!input || typeof input !== 'object' || Array.isArray(input)) return 'body must be an object';\n  const b = input as Record<string, unknown>;\n  const next: ConsumptionPolicy = { ...base };\n  for (const field of ['allowedTiers', 'requireApprovalTiers', 'secretsAllowedTiers'] as const) {\n    if (b[field] === undefined) continue;\n    const tiers = tierList(b[field], field);\n    if (typeof tiers === 'string') return tiers;\n    next[field] = tiers;\n  }\n  if (b.blockOnAdvisory !== undefined) {\n    if (!BLOCK_ORDER.includes(b.blockOnAdvisory as BlockOnAdvisory)) return 'blockOnAdvisory must be critical, high or never';\n    next.blockOnAdvisory = b.blockOnAdvisory as BlockOnAdvisory;\n  }\n  if (b.officialInstalls !== undefined) {\n    if (b.officialInstalls !== 'implicit' && b.officialInstalls !== 'explicit') return 'officialInstalls must be implicit or explicit';\n    next.officialInstalls = b.officialInstalls;\n  }\n  if (b.blockedListings !== undefined) {\n    if (!Array.isArray(b.blockedListings)) return 'blockedListings must be an array';\n    if (b.blockedListings.length > MAX_BLOCKED_LISTINGS) return `at most ${MAX_BLOCKED_LISTINGS} blocked listings`;\n    const refs: BlockedListingRef[] = [];\n    for (const raw of b.blockedListings) {\n      const ref = typeof raw === 'string'\n        ? (() => { const [publisher, name, extra] = raw.split('/'); return extra === undefined ? { publisher, name } : null; })()\n        : raw && typeof raw === 'object' ? { publisher: (raw as BlockedListingRef).publisher, name: (raw as BlockedListingRef).name } : null;\n      if (!ref || typeof ref.publisher !== 'string' || typeof ref.name !== 'string'\n        || !HANDLE_RE.test(ref.publisher) || !NAME_RE.test(ref.name)) {\n        return 'each blocked listing must be { publisher, name } (or \"publisher/name\")';\n      }\n      refs.push({ publisher: ref.publisher, name: ref.name });\n    }\n    next.blockedListings = uniqueListings(refs);\n  }\n  return next;\n}\n\n// -----------------------------------------------------------------------------\n// Refusals and warnings\n// -----------------------------------------------------------------------------\n\n/** Why a reference can't resolve; `code` is an api-core `ErrorCode` name. */\nexport interface ResolutionRefusal {\n  code: 'NOT_FOUND' | 'PLUGIN_NOT_INSTALLED' | 'PLUGIN_BLOCKED_BY_POLICY' | 'PLUGIN_UNAVAILABLE';\n  reason: string;\n  message: string;\n  details?: Record<string, unknown>;\n}\n\n/** A non-fatal note a resolution carries (synth prints it). */\nexport interface ResolutionWarning {\n  code: 'PLUGIN_ADVISORY' | 'PLUGIN_DEPRECATED' | 'PLUGIN_SECRETS_WITHHELD' | 'LISTING_UNMAINTAINED';\n  message: string;\n}\n\n/** Why the org's policy (or the listing's state) keeps a listing out, or null. */\nexport interface ListingBlock {\n  reason: 'tier' | 'blocked_listing' | 'suspended';\n  message: string;\n}\n\n/** Whether `policy` (or the listing's own state) refuses the listing outright. */\nexport function listingBlock(\n  policy: ConsumptionPolicy,\n  publisher: Pick<Publisher, 'handle' | 'tier' | 'suspendedAt'>,\n  listing: Pick<PluginListing, 'name' | 'state'>,\n): ListingBlock | null {\n  const ref = `${publisher.handle}/${listing.name}`;\n  if (publisher.suspendedAt || listing.state === 'suspended' || listing.state === 'transferred') {\n    return { reason: 'suspended', message: `${ref} is ${listing.state === 'transferred' ? 'transferred' : 'suspended'} and no longer resolves.` };\n  }\n  if (policy.blockedListings.some((b) => b.publisher === publisher.handle && b.name === listing.name)) {\n    return { reason: 'blocked_listing', message: `Your organization's plugin policy blocks ${ref}.` };\n  }\n  if (!policy.allowedTiers.includes(publisher.tier)) {\n    return { reason: 'tier', message: `Your organization's plugin policy doesn't allow ${publisher.tier} plugins (${ref}).` };\n  }\n  return null;\n}\n\n/** The refusal a {@link ListingBlock} becomes. */\nexport function blockRefusal(block: ListingBlock): ResolutionRefusal {\n  return block.reason === 'suspended'\n    ? { code: 'PLUGIN_UNAVAILABLE', reason: 'suspended', message: block.message }\n    : { code: 'PLUGIN_BLOCKED_BY_POLICY', reason: block.reason, message: block.message };\n}\n\n// -----------------------------------------------------------------------------\n// Advisories\n// -----------------------------------------------------------------------------\n\n/** Severities each `blockOnAdvisory` setting blocks. */\nexport const ADVISORY_BLOCK_SEVERITIES: Readonly<Record<BlockOnAdvisory, readonly AdvisorySeverity[]>> = {\n  critical: ['critical'],\n  high: ['critical', 'high'],\n  never: [],\n};\n\nconst COMPARATOR = /^(>=|<=|>|<|=)?\\s*v?(\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?)$/;\n\n/** One comparator set (`>=1.0.0 <1.2.3`, `^1.2`, `1.x`, `1.0.0 - 1.2.0`) against `version`. */\nfunction comparatorSetCovers(set: string, version: string): boolean {\n  const hyphen = /^(\\S+)\\s+-\\s+(\\S+)$/.exec(set);\n  if (hyphen) return compareSemver(version, hyphen[1]!) >= 0 && compareSemver(version, hyphen[2]!) <= 0;\n  const parts = set.split(/\\s+/).filter(Boolean);\n  if (parts.length === 1 && parseVersionSpec(parts[0]!)) return satisfiesVersionSpec(version, parts[0]!);\n  return parts.every((p) => {\n    const m = COMPARATOR.exec(p);\n    if (!m) return false;\n    const c = compareSemver(version, m[2]!);\n    switch (m[1] ?? '=') {\n      case '>=': return c >= 0;\n      case '<=': return c <= 0;\n      case '>': return c > 0;\n      case '<': return c < 0;\n      default: return c === 0;\n    }\n  });\n}\n\n/**\n * Whether an advisory's `affectedRange` covers `version`: `||`-separated\n * comparator sets, each either the lookup spec forms (`^`, `~`, partial,\n * exact) or space-separated comparators (`>=1.0.0 <1.2.3`) or a hyphen range.\n * `*` covers everything; an unparseable range covers nothing.\n */\nexport function advisoryRangeCovers(range: string, version: string): boolean {\n  if (!parseSemver(version)) return false;\n  return range.split('||').map((s) => s.trim()).some((set) => set === '*' || (set !== '' && comparatorSetCovers(set, version)));\n}\n\n/**\n * Why `range` isn't a usable advisory range (the forms {@link advisoryRangeCovers}\n * understands), or null when it is. An advisory whose range parses as nothing\n * would silently cover nothing, so drafts are refused instead.\n */\nexport function advisoryRangeProblem(range: string): string | null {\n  const trimmed = range.trim();\n  if (trimmed === '') return 'the affected range is empty';\n  if (trimmed.length > 255) return 'the affected range is longer than 255 characters';\n  for (const set of trimmed.split('||').map((x) => x.trim())) {\n    if (set === '*') continue;\n    if (set === '') return 'the affected range has an empty \"||\" alternative';\n    const hyphen = /^(\\S+)\\s+-\\s+(\\S+)$/.exec(set);\n    if (hyphen) {\n      if (!parseSemver(hyphen[1]!) || !parseSemver(hyphen[2]!)) return `\"${set}\" is not a valid hyphen range`;\n      continue;\n    }\n    const parts = set.split(/\\s+/).filter(Boolean);\n    if (parts.length === 1 && parts[0] !== 'latest' && parseVersionSpec(parts[0]!)) continue;\n    const bad = parts.find((x) => !COMPARATOR.test(x));\n    if (bad !== undefined) return `\"${bad}\" is not a version, a ^/~ range or a comparator (>=, <=, >, <, =)`;\n  }\n  return null;\n}\n\n/** The PUBLISHED advisories whose range covers `version` (any severity), most severe first. */\nexport function advisoriesCovering<A extends Pick<PluginAdvisory, 'severity' | 'state' | 'affectedRange'>>(\n  advisories: readonly A[],\n  version: string,\n): A[] {\n  const rank: Record<AdvisorySeverity, number> = { critical: 0, high: 1, medium: 2, low: 3 };\n  return advisories\n    .filter((a) => a.state === 'published' && advisoryRangeCovers(a.affectedRange, version))\n    .sort((a, b) => rank[a.severity] - rank[b.severity]);\n}\n\n/** The PUBLISHED advisories the policy blocks `version` for. */\nexport function blockingAdvisories(\n  advisories: readonly Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>[],\n  version: string,\n  policy: Pick<ConsumptionPolicy, 'blockOnAdvisory'>,\n): Array<Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>> {\n  const severities = ADVISORY_BLOCK_SEVERITIES[policy.blockOnAdvisory];\n  if (severities.length === 0) return [];\n  return advisories.filter((a) => a.state === 'published' && severities.includes(a.severity) && advisoryRangeCovers(a.affectedRange, version));\n}\n\n// -----------------------------------------------------------------------------\n// Installs and version choice\n// -----------------------------------------------------------------------------\n\n/** How the org reaches a listing: an explicit install row, or the implicit Official one. */\nexport type InstallMode =\n  | { kind: 'explicit'; install: PluginInstall; inherited: boolean }\n  | { kind: 'implicit' };\n\ntype VersionRow = Pick<PluginListingVersion, 'version' | 'yankedAt' | 'pausedAt' | 'breaking'>;\n\nconst isStable = (v: string): boolean => (parseSemver(v)?.prerelease.length ?? 1) === 0;\n\n/**\n * The implicit Official install's range: every version of the LOWEST live\n * major (`<major>.x`) — patch and minor versions flow, a new major never does\n * (the org moves to it with an explicit install). Null when nothing is live.\n */\nexport function implicitInstallRange(versions: readonly VersionRow[]): string | null {\n  const majors = versions\n    .filter((v) => !v.yankedAt && isStable(v.version))\n    .map((v) => parseSemver(v.version)!.major);\n  if (majors.length === 0) return null;\n  return `${Math.min(...majors)}.x`;\n}\n\n/** Whether an install's version policy admits `version` (the baseline is `pinnedVersion`). */\nexport function installAdmits(\n  install: Pick<PluginInstall, 'versionPolicy' | 'pinnedVersion'>,\n  version: string,\n  versions: readonly VersionRow[],\n): boolean {\n  const base = install.pinnedVersion;\n  switch (install.versionPolicy as InstallVersionPolicy) {\n    case 'pinned':\n      return version === base;\n    case 'patch':\n      return base !== null && satisfiesVersionSpec(version, `~${base}`);\n    case 'minor':\n      return base !== null && satisfiesVersionSpec(version, `^${base}`);\n    case 'latest': {\n      if (!isStable(version)) return false;\n      if (base === null) return true;\n      if (compareSemver(version, base) < 0) return false;\n      // Never cross a version the publisher marked breaking.\n      return !versions.some((v) => v.breaking && compareSemver(v.version, base) > 0 && compareSemver(v.version, version) <= 0);\n    }\n    default:\n      return false;\n  }\n}\n\n/** Whether `mode` admits `version` (the implicit range for an implicit install). */\nexport function modeAdmits(mode: InstallMode, version: string, versions: readonly VersionRow[]): boolean {\n  if (mode.kind === 'explicit') return installAdmits(mode.install, version, versions);\n  const range = implicitInstallRange(versions);\n  return range !== null && satisfiesVersionSpec(version, range);\n}\n\n/** Input to {@link selectListingVersion}. */\nexport interface VersionChoiceInput<V extends PluginListingVersion = PluginListingVersion> {\n  ref: string;\n  versions: readonly V[];\n  mode: InstallMode;\n  /** The reference's own version spec (`filter.version`). */\n  requested?: string;\n  advisories: readonly PluginAdvisory[];\n  policy: ConsumptionPolicy;\n}\n\n/**\n * Pick the listed version a reference resolves to (see the module doc), or\n * the refusal that explains why none can.\n */\nexport function selectListingVersion<V extends PluginListingVersion>(input: VersionChoiceInput<V>): { version: V } | { refusal: ResolutionRefusal } {\n  const { ref, versions, mode, requested, advisories, policy } = input;\n  const exact = requested !== undefined && !isVersionRange(requested) ? requested.trim() : null;\n\n  if (exact !== null) {\n    const v = versions.find((x) => x.version === exact);\n    if (!v) return { refusal: { code: 'NOT_FOUND', reason: 'version_not_found', message: `${ref} has no published version ${exact}.` } };\n    if (v.yankedAt) {\n      return {\n        refusal: {\n          code: 'PLUGIN_UNAVAILABLE',\n          reason: 'yanked',\n          message: `${ref}@${exact} is yanked${v.yankReason ? `: ${v.yankReason}` : ''}. Move to a supported version.`,\n          details: { version: exact },\n        },\n      };\n    }\n    if (mode.kind === 'explicit' && !installAdmits(mode.install, exact, versions)) {\n      return {\n        refusal: {\n          code: 'PLUGIN_NOT_INSTALLED',\n          reason: 'version_outside_install',\n          message: `${ref}@${exact} is outside your install (${mode.install.versionPolicy} from ${mode.install.pinnedVersion}). Upgrade the install first.`,\n          details: { version: exact, versionPolicy: mode.install.versionPolicy, pinnedVersion: mode.install.pinnedVersion },\n        },\n      };\n    }\n    const blocking = blockingAdvisories(advisories, exact, policy);\n    if (blocking.length) return { refusal: advisoryRefusal(ref, exact, blocking) };\n    return { version: v };\n  }\n\n  const resolvedBefore = mode.kind === 'explicit' ? mode.install.resolvedVersion : null;\n  // The range the INSTALL allows. For the implicit install an explicit spec on\n  // the reference replaces the implicit range (it is a deliberate choice).\n  const admitted = versions.filter((v) => !v.yankedAt\n    && (mode.kind === 'explicit' ? installAdmits(mode.install, v.version, versions)\n      : requested !== undefined || modeAdmits(mode, v.version, versions))\n    && (requested === undefined || satisfiesVersionSpec(v.version, requested))\n    && (!v.pausedAt || v.version === resolvedBefore));\n  const allowed = admitted.filter((v) => blockingAdvisories(advisories, v.version, policy).length === 0);\n  // Ranges only admit prereleases they name (npm semantics), so the highest\n  // admitted version is the answer.\n  const best = highest(allowed.map((v) => v.version));\n  if (best) return { version: allowed.find((v) => v.version === best)! };\n\n  if (admitted.length > 0) {\n    const newest = highest(admitted.map((v) => v.version))!;\n    return { refusal: advisoryRefusal(ref, newest, blockingAdvisories(advisories, newest, policy)) };\n  }\n  if (mode.kind === 'explicit' && requested !== undefined\n    && versions.some((v) => !v.yankedAt && satisfiesVersionSpec(v.version, requested))) {\n    return {\n      refusal: {\n        code: 'PLUGIN_NOT_INSTALLED',\n        reason: 'version_outside_install',\n        message: `No version of ${ref} matching ${requested} is inside your install (${mode.install.versionPolicy} from ${mode.install.pinnedVersion}). Upgrade the install first.`,\n        details: { requested, versionPolicy: mode.install.versionPolicy, pinnedVersion: mode.install.pinnedVersion },\n      },\n    };\n  }\n  return {\n    refusal: {\n      code: 'NOT_FOUND',\n      reason: 'no_matching_version',\n      message: `No resolvable version of ${ref}${requested ? ` matches ${requested}` : ''}.`,\n    },\n  };\n}\n\n/** The highest of `versions` by semver (prereleases included). */\nfunction highest(versions: readonly string[]): string | null {\n  return versions.reduce<string | null>((best, v) => (best === null || compareSemver(v, best) > 0 ? v : best), null);\n}\n\nfunction advisoryRefusal(ref: string, version: string, blocking: ReadonlyArray<Pick<PluginAdvisory, 'id' | 'severity' | 'fixedVersion' | 'summary'>>): ResolutionRefusal {\n  const fixed = blocking.map((a) => a.fixedVersion).filter((v): v is string => !!v);\n  return {\n    code: 'PLUGIN_BLOCKED_BY_POLICY',\n    reason: 'advisory',\n    message: `${ref}@${version} is blocked by your organization's advisory policy: ${blocking.map((a) => `${a.severity} — ${a.summary}`).join('; ')}.`\n      + (fixed.length ? ` Fixed in ${fixed.join(', ')}.` : ''),\n    details: { version, advisories: blocking.map((a) => a.id), ...(fixed.length ? { fixedVersions: fixed } : {}) },\n  };\n}\n\n// -----------------------------------------------------------------------------\n// The org's install state for one listing\n// -----------------------------------------------------------------------------\n\n/** The org (and, for a team, its root org) a resolution runs for. */\nexport interface ResolutionScope {\n  orgId: string;\n  /** The root org when the caller is a team. */\n  rootOrgId?: string;\n}\n\n/** The org ids whose installs and policies apply, own first. */\nexport function scopeOrgIds(scope: ResolutionScope): string[] {\n  const own = scope.orgId.toLowerCase();\n  const root = scope.rootOrgId?.toLowerCase();\n  return root && root !== own ? [own, root] : [own];\n}\n\n/**\n * How the org reaches `listing` — or the refusal. An ACTIVE own-org row wins,\n * then the root org's (a team inherits it); failing both, the implicit\n * Official install (unless the policy is `explicit`); otherwise the org's own\n * pending / denied row explains the refusal.\n */\nexport function installModeFor(\n  publisher: Pick<Publisher, 'handle'>,\n  listing: Pick<PluginListing, 'id' | 'name'>,\n  installs: readonly PluginInstall[],\n  policy: ConsumptionPolicy,\n  scope: ResolutionScope,\n): InstallMode | ResolutionRefusal {\n  const [own, root] = scopeOrgIds(scope);\n  const forListing = installs.filter((i) => i.listingId === listing.id);\n  const ownRow = forListing.find((i) => i.orgId.toLowerCase() === own);\n  const rootRow = root ? forListing.find((i) => i.orgId.toLowerCase() === root) : undefined;\n  if (ownRow?.status === 'active') return { kind: 'explicit', install: ownRow, inherited: false };\n  if (rootRow?.status === 'active') return { kind: 'explicit', install: rootRow, inherited: true };\n  const ref = `${publisher.handle}/${listing.name}`;\n  if (publisher.handle === OFFICIAL_PUBLISHER_HANDLE) {\n    if (policy.officialInstalls === 'implicit') return { kind: 'implicit' };\n    if (!ownRow) {\n      return {\n        code: 'PLUGIN_NOT_INSTALLED',\n        reason: 'official_explicit',\n        message: `Your organization installs Official plugins explicitly; install ${ref} first.`,\n      };\n    }\n  }\n  if (ownRow?.status === 'pending_approval') {\n    return { code: 'PLUGIN_NOT_INSTALLED', reason: 'pending_approval', message: `The install of ${ref} is waiting for approval.` };\n  }\n  if (ownRow?.status === 'denied') {\n    return { code: 'PLUGIN_NOT_INSTALLED', reason: 'denied', message: `The install of ${ref} was denied.` };\n  }\n  return { code: 'PLUGIN_NOT_INSTALLED', reason: 'not_installed', message: `${ref} is not installed in your organization.` };\n}\n\n// -----------------------------------------------------------------------------\n// Data source\n// -----------------------------------------------------------------------------\n\n/** The rows the resolver reads. Implementations must run with a scope that can\n *  read the ecosystem tables and the org's (and root org's) install rows. */\nexport interface ListingDataSource {\n  publisherByHandle(handle: string): Promise<Publisher | null>;\n  publishersByIds(ids: string[]): Promise<Publisher[]>;\n  listingByName(publisherId: string, name: string): Promise<PluginListing | null>;\n  /** Listed / unmaintained listings (optionally only these ids or names). */\n  liveListings(filter?: { ids?: string[]; names?: string[] }): Promise<PluginListing[]>;\n  versionsForListings(listingIds: string[]): Promise<PluginListingVersion[]>;\n  /** PUBLISHED advisories. */\n  advisoriesForListings(listingIds: string[]): Promise<PluginAdvisory[]>;\n  installsForOrgs(orgIds: string[]): Promise<PluginInstall[]>;\n  policiesForOrgs(orgIds: string[]): Promise<PluginInstallPolicy[]>;\n}\n\n/**\n * A {@link ListingDataSource} over a drizzle transaction. The caller owns the\n * transaction's scope: it must be able to read the ecosystem tables (app-role\n * RLS) and the install rows of the org AND its root org (a team's reads of its\n * root's rows need an elevated scope, like parent-org plugin reads).\n */\nexport function drizzleListingSource(tx: CrudTx): ListingDataSource {\n  const db = tx;\n  const P = schema.publisher;\n  const L = schema.pluginListing;\n  const V = schema.pluginListingVersion;\n  const A = schema.pluginAdvisory;\n  const I = schema.pluginInstall;\n  const IP = schema.pluginInstallPolicy;\n  return {\n    publisherByHandle: async (handle) => ((await db.select().from(P).where(eq(P.handle, handle))) as Publisher[])[0] ?? null,\n    publishersByIds: async (ids) => (ids.length ? db.select().from(P).where(inArray(P.id, ids)) : []),\n    listingByName: async (publisherId, name) =>\n      ((await db.select().from(L).where(and(eq(L.publisherId, publisherId), eq(L.name, name)))) as PluginListing[])[0] ?? null,\n    liveListings: async (filter = {}) => {\n      if (filter.ids && filter.ids.length === 0) return [];\n      if (filter.names && filter.names.length === 0) return [];\n      return db.select().from(L).where(and(\n        inArray(L.state, ['listed', 'unmaintained']),\n        ...(filter.ids ? [inArray(L.id, filter.ids)] : []),\n        ...(filter.names ? [inArray(L.name, filter.names)] : []),\n      ));\n    },\n    versionsForListings: async (ids) => (ids.length ? db.select().from(V).where(inArray(V.listingId, ids)) : []),\n    advisoriesForListings: async (ids) => (ids.length ? db.select().from(A).where(and(inArray(A.listingId, ids), eq(A.state, 'published'))) : []),\n    installsForOrgs: async (orgIds) => (orgIds.length ? db.select().from(I).where(inArray(I.orgId, orgIds)) : []),\n    policiesForOrgs: async (orgIds) => (orgIds.length ? db.select().from(IP).where(inArray(IP.orgId, orgIds)) : []),\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Resolution\n// -----------------------------------------------------------------------------\n\n/** A plugin reference as the resolver reads it. */\nexport interface ListingReference {\n  /** Publisher handle; absent = the Official listing (the unqualified fallback). */\n  publisher?: string;\n  name: string;\n  /** The reference's `filter.version`. */\n  version?: string;\n}\n\n/** A reference that resolved to a listed version. */\nexport interface ListingResolved {\n  ok: true;\n  publisher: Publisher;\n  listing: PluginListing;\n  version: PluginListingVersion;\n  mode: InstallMode;\n  policy: ConsumptionPolicy;\n  /** The spec declares secrets the policy withholds from this tier. */\n  secretsWithheld: boolean;\n  warnings: ResolutionWarning[];\n}\n\n/** A reference that named a listing but can't resolve. */\nexport interface ListingRefused {\n  ok: false;\n  refusal: ResolutionRefusal;\n  publisher?: Publisher;\n  listing?: PluginListing;\n}\n\n/**\n * Resolve `ref` to a listed version for `scope`, or refuse. Null when the\n * listing doesn't exist at all (an unqualified reference then simply has no\n * Official fallback).\n */\nexport async function resolveListingReference(\n  source: ListingDataSource,\n  ref: ListingReference,\n  scope: ResolutionScope,\n): Promise<ListingResolved | ListingRefused | null> {\n  const handle = ref.publisher ?? OFFICIAL_PUBLISHER_HANDLE;\n  const publisher = await source.publisherByHandle(handle);\n  if (!publisher) return null;\n  const listing = await source.listingByName(publisher.id, ref.name);\n  if (!listing) return null;\n\n  const orgIds = scopeOrgIds(scope);\n  const [policies, installs] = await Promise.all([source.policiesForOrgs(orgIds), source.installsForOrgs(orgIds)]);\n  const policy = effectiveConsumptionPolicy(policies, orgIds[0]!, orgIds[1]);\n  const block = listingBlock(policy, publisher, listing);\n  if (block) return { ok: false, refusal: blockRefusal(block), publisher, listing };\n\n  const mode = installModeFor(publisher, listing, installs, policy, scope);\n  if ('code' in mode) return { ok: false, refusal: mode, publisher, listing };\n\n  const [versions, advisories] = await Promise.all([\n    source.versionsForListings([listing.id]),\n    source.advisoriesForListings([listing.id]),\n  ]);\n  const ref_ = `${publisher.handle}/${listing.name}`;\n  const choice = selectListingVersion({ ref: ref_, versions, mode, requested: ref.version, advisories, policy });\n  if ('refusal' in choice) return { ok: false, refusal: choice.refusal, publisher, listing };\n\n  const version = choice.version;\n  const { warnings, secretsWithheld } = listedVersionWarnings({ publisher, listing, version, advisories, policy });\n  return { ok: true, publisher, listing, version, mode, policy, secretsWithheld, warnings };\n}\n\n/**\n * The non-fatal notes a resolved listed version carries (lookup answers,\n * synth prints them, the installs view shows them): an unmaintained listing, a\n * deprecated version, a PUBLISHED advisory covering the version that the org's\n * `blockOnAdvisory` doesn't block (a blocking one refuses resolution instead),\n * and withheld secrets.\n */\nexport function listedVersionWarnings(input: {\n  publisher: Pick<Publisher, 'handle' | 'tier'>;\n  listing: Pick<PluginListing, 'name' | 'state'>;\n  version: Pick<PluginListingVersion, 'version' | 'deprecatedAt' | 'deprecationMessage' | 'specSnapshot'>;\n  advisories: readonly Pick<PluginAdvisory, 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>[];\n  policy: Pick<ConsumptionPolicy, 'secretsAllowedTiers'>;\n}): { warnings: ResolutionWarning[]; secretsWithheld: boolean } {\n  const { publisher, listing, version, advisories, policy } = input;\n  const ref = `${publisher.handle}/${listing.name}`;\n  const declaresSecrets = (version.specSnapshot?.secrets ?? []).length > 0;\n  const secretsWithheld = declaresSecrets && !policy.secretsAllowedTiers.includes(publisher.tier);\n  const warnings: ResolutionWarning[] = [];\n  if (listing.state === 'unmaintained') {\n    warnings.push({ code: 'LISTING_UNMAINTAINED', message: `${ref} is unmaintained: it receives no updates. Plan a replacement.` });\n  }\n  if (version.deprecatedAt) {\n    warnings.push({ code: 'PLUGIN_DEPRECATED', message: `${ref}@${version.version} is deprecated${version.deprecationMessage ? `: ${version.deprecationMessage}` : ''}.` });\n  }\n  for (const a of advisoriesCovering(advisories, version.version)) {\n    warnings.push({\n      code: 'PLUGIN_ADVISORY',\n      message: `${ref}@${version.version} is affected by a ${a.severity} security advisory: ${a.summary}`\n        + `${a.fixedVersion ? ` Fixed in ${a.fixedVersion}.` : ''}`,\n    });\n  }\n  if (secretsWithheld) {\n    warnings.push({ code: 'PLUGIN_SECRETS_WITHHELD', message: `${ref} is a ${publisher.tier} plugin; your organization's policy gives it no secrets, so its declared secrets are not injected.` });\n  }\n  return { warnings, secretsWithheld };\n}\n\n/**\n * The plugin record a resolved listing version runs as — the shape synth and\n * the contract check read (a `plugins` row's run fields), built from the\n * version's frozen spec snapshot. `id` is the LISTING VERSION's id (the step\n * manifest resolves it back), `imageRepository` its `public/*` copy.\n */\nexport function listedPluginRecord(res: ListingResolved): Record<string, unknown> {\n  const { publisher, listing, version, mode } = res;\n  const s = (version.specSnapshot ?? {}) as Record<string, unknown>;\n  const arr = <T>(v: unknown): T[] => (Array.isArray(v) ? v as T[] : []);\n  const obj = (v: unknown): Record<string, unknown> => (v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : {});\n  return {\n    id: version.id,\n    source: 'listing',\n    publisher: publisher.handle,\n    publisherTier: publisher.tier,\n    listingId: listing.id,\n    install: mode.kind,\n    name: listing.name,\n    version: version.version,\n    imageRepository: version.imageRepository,\n    imageDigest: version.imageDigest,\n    buildType: typeof s.buildType === 'string' ? s.buildType : (version.imageDigest ? 'build_image' : 'metadata_only'),\n    pluginType: s.pluginType ?? 'CodeBuildStep',\n    computeType: s.computeType ?? 'SMALL',\n    description: s.description ?? listing.description ?? null,\n    summary: s.summary ?? listing.summary ?? null,\n    displayName: s.displayName ?? null,\n    keywords: arr<string>(s.keywords),\n    category: s.category ?? listing.category,\n    metadata: obj(s.metadata),\n    env: obj(s.env),\n    buildArgs: {},\n    installCommands: arr<string>(s.installCommands),\n    commands: arr<string>(s.commands),\n    timeout: s.timeout ?? null,\n    failureBehavior: s.failureBehavior ?? 'fail',\n    primaryOutputDirectory: s.primaryOutputDirectory ?? null,\n    secrets: res.secretsWithheld ? [] : arr(s.secrets),\n    requiredMetadata: arr<string>(s.requiredMetadata),\n    requiredVars: arr<string>(s.requiredVars),\n    metadataTypes: obj(s.metadataTypes),\n    varsTypes: obj(s.varsTypes),\n    networkEgress: arr<string>(s.networkEgress),\n    runAsRoot: s.runAsRoot ?? null,\n    license: s.license ?? listing.license ?? null,\n    homepageUrl: s.homepageUrl ?? listing.homepageUrl ?? null,\n    sourceUrl: s.sourceUrl ?? listing.sourceUrl ?? null,\n    documentationUrl: s.documentationUrl ?? null,\n    icon: s.icon ?? listing.icon ?? null,\n    changelog: version.changelog,\n    breaking: version.breaking,\n    vulnCritical: version.vulnCritical,\n    vulnHigh: version.vulnHigh,\n    scannedAt: version.scannedAt,\n    lifecycle: version.deprecatedAt ? 'deprecated' : 'production',\n    deprecatedAt: version.deprecatedAt,\n    deprecationMessage: version.deprecationMessage,\n    yankedAt: null,\n    yankReason: null,\n    visibility: 'public',\n    isDefault: true,\n    isActive: true,\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Everything an org can resolve (catalog, AI selection, placeholder guard)\n// -----------------------------------------------------------------------------\n\n/** One listing with the org's standing on it. */\nexport interface OrgListingState {\n  publisher: Publisher;\n  listing: PluginListing;\n  versions: PluginListingVersion[];\n  /** How the org reaches it, or why it can't (not installed, pending, …). */\n  mode: InstallMode | ResolutionRefusal;\n  /** A policy / state block (tier, blocked listing, suspended), or null. */\n  block: ListingBlock | null;\n  /** What an UNVERSIONED reference resolves to right now, or null. */\n  resolved: PluginListingVersion | null;\n  /** Why nothing resolves, when the org does reach the listing (e.g. an advisory block). */\n  refusal: ResolutionRefusal | null;\n  /** The listing's PUBLISHED advisories. */\n  advisories: PluginAdvisory[];\n  /** The org's own install row for it (explicit, possibly pending/denied). */\n  ownInstall: PluginInstall | null;\n  /** The org's effective consumption policy (the same for every listing). */\n  policy: ConsumptionPolicy;\n}\n\n/** The org's policy + install rows (own and root). */\nexport interface OrgInstallContext {\n  policy: ConsumptionPolicy;\n  installs: PluginInstall[];\n  scope: ResolutionScope;\n}\n\n/** Load the org's policy and install rows. */\nexport async function loadOrgInstallContext(source: ListingDataSource, scope: ResolutionScope): Promise<OrgInstallContext> {\n  const orgIds = scopeOrgIds(scope);\n  const [policies, installs] = await Promise.all([source.policiesForOrgs(orgIds), source.installsForOrgs(orgIds)]);\n  return { policy: effectiveConsumptionPolicy(policies, orgIds[0]!, orgIds[1]), installs, scope };\n}\n\n/**\n * The org's standing on every live listing (or only `filter`'s). Used by the\n * in-app catalog; {@link resolvableListings} narrows it to what resolves.\n */\nexport async function orgListingStates(\n  source: ListingDataSource,\n  scope: ResolutionScope,\n  filter: { ids?: string[]; names?: string[] } = {},\n  ctx?: OrgInstallContext,\n): Promise<OrgListingState[]> {\n  const context = ctx ?? await loadOrgInstallContext(source, scope);\n  const live = await source.liveListings(filter);\n  if (live.length === 0) return [];\n  const ids = live.map((l) => l.id);\n  const [pubs, versions, advisories] = await Promise.all([\n    source.publishersByIds([...new Set(live.map((l) => l.publisherId))]),\n    source.versionsForListings(ids),\n    source.advisoriesForListings(ids),\n  ]);\n  const byPublisher = new Map(pubs.map((p) => [p.id, p]));\n  const own = scopeOrgIds(scope)[0]!;\n  const out: OrgListingState[] = [];\n  for (const listing of live) {\n    const publisher = byPublisher.get(listing.publisherId);\n    if (!publisher) continue;\n    const vs = versions.filter((v) => v.listingId === listing.id);\n    const block = listingBlock(context.policy, publisher, listing);\n    const mode = installModeFor(publisher, listing, context.installs, context.policy, scope);\n    const listingAdvisories = advisories.filter((a) => a.listingId === listing.id);\n    let resolved: PluginListingVersion | null = null;\n    let refusal: ResolutionRefusal | null = null;\n    if (!block && !('code' in mode)) {\n      const choice = selectListingVersion({\n        ref: `${publisher.handle}/${listing.name}`, versions: vs, mode, advisories: listingAdvisories, policy: context.policy,\n      });\n      if ('version' in choice) resolved = choice.version;\n      else refusal = choice.refusal;\n    }\n    const ownInstall = context.installs.find((i) => i.listingId === listing.id && i.orgId.toLowerCase() === own) ?? null;\n    out.push({ publisher, listing, versions: vs, mode, block, resolved, refusal, advisories: listingAdvisories, ownInstall, policy: context.policy });\n  }\n  return out;\n}\n\n/** The listings an org's references resolve to now (installed or implicit, not blocked). */\nexport async function resolvableListings(\n  source: ListingDataSource,\n  scope: ResolutionScope,\n  filter: { names?: string[] } = {},\n): Promise<Array<OrgListingState & { resolved: PluginListingVersion }>> {\n  return (await orgListingStates(source, scope, filter))\n    .filter((s): s is OrgListingState & { resolved: PluginListingVersion } => s.resolved !== null);\n}\n"]}