@pipeline-builder/pipeline-data 4.1.15 → 4.1.16

package/lib/api/public-directory.js

@@ -0,0 +1,457 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Queries behind the anonymous public plugin directory
+ * (docs/plugin-publishing.md).
+ *
+ * Every query here reads ONLY the `public_listings`, `public_listed_versions`,
+ * `public_advisories` and `public_reviews` views, through the `ecosystem_public_reader`
+ * connection ({@link getPublicReaderDb}). Those views already filter to public
+ * rows (listed/unmaintained listings of non-suspended publishers, non-paused
+ * versions, published advisories) and project public columns only, so nothing
+ * here needs — or has — a tenant context.
+ *
+ * Search: Postgres full-text (`search_vector`, weighted name A / keywords and
+ * category B / summary C / README D, `english` config) OR a trigram match on the
+ * name (typo tolerance), ranked by `ts_rank` + name similarity, blended with the
+ * Bayesian rating and install count when present. Paused listings are hidden.
+ */
+import { sql } from 'drizzle-orm';
+import { advisoryRangeCovers } from './plugin-resolution.js';
+import { compareSemver } from './semver-range.js';
+import { resultRows } from '../database/pg-result.js';
+import { getPublicReaderDb } from '../database/public-reader.js';
+export const DIRECTORY_SORTS = ['relevance', 'rating', 'installs', 'updated', 'name', 'health'];
+export const DIRECTORY_TIERS = ['official', 'verified', 'community', 'unverified'];
+/** Minimum `word_similarity(query, name)` for a fuzzy name match (typo tolerance). */
+export const FUZZY_NAME_THRESHOLD = 0.3;
+/** Max query length accepted (longer is truncated, never an error). */
+export const DIRECTORY_MAX_QUERY_LENGTH = 100;
+export const DIRECTORY_DEFAULT_LIMIT = 24;
+export const DIRECTORY_MAX_LIMIT = 60;
+export const REVIEW_SORTS = ['helpful', 'recent', 'highest', 'lowest'];
+export const REVIEWS_DEFAULT_LIMIT = 10;
+export const REVIEWS_MAX_LIMIT = 50;
+function num(v) {
+    const n = typeof v === 'number' ? v : Number.parseFloat(String(v ?? '0'));
+    return Number.isFinite(n) ? n : 0;
+}
+function iso(v) {
+    if (!v)
+        return '';
+    return v instanceof Date ? v.toISOString() : new Date(v).toISOString();
+}
+/**
+ * The icon fallback chain: uploaded (if the tier may upload) → curated
+ * vendor key (Official, and Verified publishers for marks they own — ownership
+ * is checked when the icon is approved) → monogram. Community and anonymous
+ * listings can never show a curated vendor mark.
+ */
+export function resolveListingIcon(row) {
+    const none = { iconUrl: null, iconKey: null, iconBadge: null, iconHex: null };
+    if (row.uploaded_icon?.key256) {
+        return { ...none, iconKind: 'uploaded', iconUrl: `/api/public/plugins/icons/${encodeURIComponent(row.uploaded_icon.key256)}` };
+    }
+    const curatedAllowed = row.publisher_tier === 'official' || row.publisher_tier === 'verified';
+    if (curatedAllowed && row.icon?.key) {
+        return { ...none, iconKind: 'vendor', iconKey: row.icon.key, iconBadge: row.icon.badge ?? null };
+    }
+    return { ...none, iconKind: 'monogram' };
+}
+export function toListingCard(row) {
+    const ratingCount = num(row.rating_count);
+    return {
+        publisher: { handle: row.publisher_handle, displayName: row.publisher_display_name, tier: row.publisher_tier },
+        name: row.name,
+        summary: row.summary ?? '',
+        category: row.category,
+        keywords: row.keywords ?? [],
+        latestVersion: row.latest_version ?? '',
+        license: row.license ?? '',
+        ...resolveListingIcon(row),
+        rating: ratingCount > 0 && row.rating_bayes != null ? { score: Math.round(num(row.rating_bayes) * 100) / 100, count: ratingCount } : null,
+        installCount: num(row.install_count),
+        healthScore: row.health_score == null ? null : Math.round(num(row.health_score)),
+        updatedAt: iso(row.updated_at),
+        state: row.state,
+    };
+}
+// -----------------------------------------------------------------------------
+// Search
+// -----------------------------------------------------------------------------
+/** Normalize the user's query: collapse whitespace, cap the length. */
+export function normalizeQuery(q) {
+    return (q ?? '').replace(/\s+/g, ' ').trim().slice(0, DIRECTORY_MAX_QUERY_LENGTH);
+}
+/** Search terms for highlighting: words of ≥ 2 characters, regex-escaped. */
+function highlightTerms(q) {
+    return [...new Set(q.toLowerCase().split(/[^a-z0-9._-]+/).filter((t) => t.length >= 2))]
+        .map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+}
+/**
+ * Wrap matched terms in `<mark>`. The frontend renders everything except the
+ * `<mark>` markers as TEXT (never HTML), so the source text is not escaped here.
+ * Returns undefined when nothing matched (the card then renders plain text).
+ */
+export function highlightText(text, q) {
+    const terms = highlightTerms(q);
+    if (!text || terms.length === 0)
+        return undefined;
+    const re = new RegExp(`(${terms.join('|')})`, 'gi');
+    if (!re.test(text))
+        return undefined;
+    return text.replace(re, '<mark>$1</mark>');
+}
+/** Opaque cursor: an offset, base64url-encoded so clients don't depend on it. */
+export function encodeOffsetCursor(offset) {
+    return Buffer.from(JSON.stringify({ o: offset })).toString('base64url');
+}
+export function decodeOffsetCursor(cursor) {
+    if (!cursor)
+        return 0;
+    try {
+        const o = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8')).o;
+        return typeof o === 'number' && Number.isInteger(o) && o >= 0 && o <= 10_000 ? o : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function clampLimit(limit) {
+    if (!limit || !Number.isFinite(limit))
+        return DIRECTORY_DEFAULT_LIMIT;
+    return Math.min(Math.max(Math.trunc(limit), 1), DIRECTORY_MAX_LIMIT);
+}
+/**
+ * The filtered base set as a CTE body. Every search, facet and category query
+ * reads through this, so they can't disagree about what's visible.
+ */
+function baseQuery(params, q) {
+    const where = [sql `l.paused_at IS NULL`];
+    if (q) {
+        // Full text, OR a fuzzy match against the best-matching PART of the name
+        // (word_similarity: "terafrom" → terraform-plan scores 0.36, while unrelated
+        // words stay ≤ 0.2 — whole-name similarity() dilutes a long name below any
+        // useful threshold). Explicit function, not the `<%` operator, so the cut-off
+        // doesn't depend on a session GUC pgbouncer can't carry. A seq scan over the
+        // public listings (thousands of rows at most) is fine.
+        where.push(sql `(l.search_vector @@ websearch_to_tsquery('english', ${q}) OR word_similarity(${q}, l.name) >= ${FUZZY_NAME_THRESHOLD} OR l.name ILIKE ${`%${q.replace(/[\\%_]/g, '\\$&')}%`})`);
+    }
+    if (params.category)
+        where.push(sql `l.category = ${params.category}`);
+    if (params.tier)
+        where.push(sql `l.publisher_tier = ${params.tier}`);
+    if (params.license)
+        where.push(sql `l.license = ${params.license}`);
+    if (params.computeType)
+        where.push(sql `v.compute_type = ${params.computeType}`);
+    if (params.needsSecrets !== undefined) {
+        where.push(params.needsSecrets
+            ? sql `jsonb_array_length(COALESCE(v.secrets, '[]'::jsonb)) > 0`
+            : sql `jsonb_array_length(COALESCE(v.secrets, '[]'::jsonb)) = 0`);
+    }
+    if (params.minRating !== undefined && Number.isFinite(params.minRating)) {
+        where.push(sql `l.rating_bayes >= ${params.minRating}`);
+    }
+    const rank = q
+        ? sql `(ts_rank(l.search_vector, websearch_to_tsquery('english', ${q})) + word_similarity(${q}, l.name))`
+        : sql `0::real`;
+    return sql `
+    SELECT l.id, l.publisher_handle, l.publisher_display_name, l.publisher_tier, l.name, l.category,
+           l.summary, l.description, l.readme_html, l.license, l.homepage_url, l.source_url, l.icon,
+           l.uploaded_icon, l.keywords, l.latest_version, l.updated_at, l.rating_bayes, l.rating_count,
+           l.rating_dist, l.install_count, l.active_org_count, l.health_score, l.state,
+           v.compute_type,
+           (jsonb_array_length(COALESCE(v.secrets, '[]'::jsonb)) > 0) AS needs_secrets,
+           ${rank} AS rank
+      FROM public_listings l
+      LEFT JOIN LATERAL (
+        SELECT pv.compute_type, pv.secrets
+          FROM public_listed_versions pv
+         WHERE pv.listing_id = l.id AND pv.version = l.latest_version AND NOT pv.yanked
+         LIMIT 1
+      ) v ON true
+     WHERE ${sql.join(where, sql ` AND `)}`;
+}
+function orderBy(sort, hasQuery) {
+    switch (sort === 'relevance' && !hasQuery ? 'updated' : sort) {
+        case 'relevance':
+            // Text relevance first, nudged by rating and adoption so equal matches
+            // favour proven plugins.
+            return sql `(rank * (1 + COALESCE(rating_bayes, 0) / 10) + ln(1 + install_count) / 20) DESC, name ASC`;
+        case 'rating':
+            return sql `rating_bayes DESC NULLS LAST, rating_count DESC, name ASC`;
+        case 'installs':
+            return sql `install_count DESC, name ASC`;
+        case 'name':
+            return sql `name ASC, publisher_handle ASC`;
+        case 'health':
+            return sql `health_score DESC NULLS LAST, install_count DESC, name ASC`;
+        case 'updated':
+        default:
+            return sql `updated_at DESC, name ASC`;
+    }
+}
+/** Search the directory: one page of cards, facet counts, total and next cursor. */
+export async function searchPublicListings(params) {
+    const db = getPublicReaderDb();
+    const q = normalizeQuery(params.q);
+    const limit = clampLimit(params.limit);
+    const offset = decodeOffsetCursor(params.cursor);
+    const sort = params.sort && DIRECTORY_SORTS.includes(params.sort) ? params.sort : 'relevance';
+    const base = baseQuery(params, q);
+    const [pageRes, facetRes] = await Promise.all([
+        db.execute(sql `
+      WITH base AS (${base})
+      SELECT base.*, COUNT(*) OVER () AS total
+        FROM base
+       ORDER BY ${orderBy(sort, q !== '')}
+       LIMIT ${limit} OFFSET ${offset}`),
+        db.execute(sql `
+      WITH base AS (${base})
+      SELECT category, publisher_tier, license, compute_type, needs_secrets,
+             GROUPING(category) AS g_category, GROUPING(publisher_tier) AS g_tier,
+             GROUPING(license) AS g_license, GROUPING(compute_type) AS g_compute,
+             GROUPING(needs_secrets) AS g_secrets,
+             COUNT(*) AS n
+        FROM base
+       GROUP BY GROUPING SETS ((category), (publisher_tier), (license), (compute_type), (needs_secrets))`),
+    ]);
+    const page = resultRows(pageRes);
+    const total = page.length > 0 ? num(page[0].total) : 0;
+    const items = page.map((row) => {
+        const card = toListingCard(row);
+        if (q) {
+            const highlight = { name: highlightText(card.name, q), summary: highlightText(card.summary, q) };
+            if (highlight.name || highlight.summary)
+                card.highlight = highlight;
+        }
+        return card;
+    });
+    const facets = {
+        category: {}, tier: {}, license: {}, computeType: {}, needsSecrets: { true: 0, false: 0 },
+    };
+    for (const r of resultRows(facetRes)) {
+        const n = num(r.n);
+        if (Number(r.g_category) === 0 && r.category)
+            facets.category[r.category] = n;
+        else if (Number(r.g_tier) === 0 && r.publisher_tier)
+            facets.tier[r.publisher_tier] = n;
+        else if (Number(r.g_license) === 0 && r.license)
+            facets.license[r.license] = n;
+        else if (Number(r.g_compute) === 0 && r.compute_type)
+            facets.computeType[r.compute_type] = n;
+        else if (Number(r.g_secrets) === 0 && r.needs_secrets !== null)
+            facets.needsSecrets[r.needs_secrets ? 'true' : 'false'] = n;
+    }
+    return {
+        items,
+        facets,
+        total,
+        nextCursor: offset + items.length < total ? encodeOffsetCursor(offset + items.length) : null,
+    };
+}
+// -----------------------------------------------------------------------------
+// Categories
+// -----------------------------------------------------------------------------
+/** Every category with its live count and its top listings (by rating, then installs). */
+export async function listPublicCategories(topPerCategory = 3) {
+    const db = getPublicReaderDb();
+    const res = await db.execute(sql `
+    WITH ranked AS (
+      SELECT l.*,
+             ROW_NUMBER() OVER (PARTITION BY l.category
+                                ORDER BY l.rating_bayes DESC NULLS LAST, l.install_count DESC, l.name ASC) AS rn,
+             COUNT(*) OVER (PARTITION BY l.category) AS category_count
+        FROM public_listings l
+       WHERE l.paused_at IS NULL
+    )
+    SELECT * FROM ranked WHERE rn <= ${Math.max(0, Math.min(topPerCategory, 10))} ORDER BY category ASC, rn ASC`);
+    const byCategory = new Map();
+    for (const row of resultRows(res)) {
+        let summary = byCategory.get(row.category);
+        if (!summary) {
+            summary = { id: row.category, count: num(row.category_count), top: [] };
+            byCategory.set(row.category, summary);
+        }
+        summary.top.push(toListingCard(row));
+    }
+    return [...byCategory.values()];
+}
+/**
+ * One listing's page data, or null when it isn't public (unknown, suspended,
+ * transferred, paused by its publisher — or its publisher is suspended).
+ */
+export async function getPublicListing(publisherHandle, name) {
+    const db = getPublicReaderDb();
+    const listingRes = await db.execute(sql `
+    SELECT * FROM public_listings
+     WHERE publisher_handle = ${publisherHandle} AND name = ${name} AND paused_at IS NULL
+     LIMIT 1`);
+    const row = resultRows(listingRes)[0];
+    if (!row)
+        return null;
+    const [versionRes, advisoryRes] = await Promise.all([
+        db.execute(sql `SELECT * FROM public_listed_versions WHERE listing_id = ${row.id}`),
+        db.execute(sql `SELECT * FROM public_advisories WHERE listing_id = ${row.id} ORDER BY published_at DESC`),
+    ]);
+    const versionRows = resultRows(versionRes).sort((a, b) => compareSemver(b.version, a.version));
+    const advisoryRows = resultRows(advisoryRes);
+    // The version the page describes: the listing's latest, else the newest non-yanked one.
+    const current = versionRows.find((v) => v.version === row.latest_version && !v.yanked)
+        ?? versionRows.find((v) => !v.yanked)
+        ?? null;
+    const dist = row.rating_dist ?? null;
+    const card = toListingCard(row);
+    return {
+        ...card,
+        readmeHtml: row.readme_html ?? current?.readme_html ?? null,
+        description: row.description ?? '',
+        homepageUrl: row.homepage_url,
+        sourceUrl: row.source_url,
+        versions: versionRows.map((v) => ({
+            version: v.version,
+            publishedAt: iso(v.published_at),
+            breaking: v.breaking,
+            deprecated: v.deprecated_at != null,
+            deprecationMessage: v.deprecation_message,
+            yanked: v.yanked,
+            changelog: v.changelog,
+            vulnCritical: v.vuln_critical,
+            vulnHigh: v.vuln_high,
+            scannedAt: v.scanned_at ? iso(v.scanned_at) : null,
+            advisoryIds: advisoryRows.filter((a) => advisoryRangeCovers(a.affected_range, v.version)).map((a) => a.id),
+        })),
+        configuration: {
+            secrets: (current?.secrets ?? []).map((s) => ({ name: s.name, required: s.required, description: s.description ?? '' })),
+            requiredMetadata: current?.required_metadata ?? [],
+            requiredVars: current?.required_vars ?? [],
+            computeType: current?.compute_type ?? '',
+            primaryOutputDirectory: null,
+            networkEgress: current?.network_egress ?? [],
+            pluginType: current?.plugin_type ?? '',
+        },
+        supplyChain: {
+            // A listed version exists only after the platform re-signed it in public/*.
+            signed: current?.image_digest != null,
+            digest: current?.image_digest ?? null,
+            imageSource: current?.image_source ?? null,
+            scannedAt: current?.scanned_at ? iso(current.scanned_at) : null,
+            vulnCritical: current?.vuln_critical ?? null,
+            vulnHigh: current?.vuln_high ?? null,
+            sbomUrl: current?.image_digest
+                ? `/api/public/plugins/${encodeURIComponent(row.publisher_handle)}/${encodeURIComponent(row.name)}/versions/${encodeURIComponent(current.version)}/sbom`
+                : null,
+        },
+        advisories: advisoryRows.map((a) => ({
+            id: a.id,
+            severity: a.severity,
+            summary: a.summary,
+            affectedRange: a.affected_range,
+            fixedVersion: a.fixed_version,
+            publishedAt: iso(a.published_at),
+            detailsHtml: a.details_html,
+            cveIds: a.cve_ids ?? [],
+        })),
+        ratingDistribution: dist
+            ? { 1: num(dist['1']), 2: num(dist['2']), 3: num(dist['3']), 4: num(dist['4']), 5: num(dist['5']) }
+            : null,
+        recentRating: row.recent_rating == null ? null : Math.round(num(row.recent_rating) * 100) / 100,
+        activeOrgCount: row.active_org_count == null ? null : num(row.active_org_count),
+        healthBreakdown: row.health_breakdown ?? null,
+        successRate30d: row.success_rate_30d == null ? null : Math.round(num(row.success_rate_30d) * 1000) / 1000,
+    };
+}
+/** One listed version's public image identity (for the SBOM download), or null. */
+export async function getPublicListedVersion(publisherHandle, name, version) {
+    const db = getPublicReaderDb();
+    const res = await db.execute(sql `
+    SELECT image_repository, image_digest FROM public_listed_versions
+     WHERE publisher_handle = ${publisherHandle} AND name = ${name} AND version = ${version} AND NOT yanked
+       AND listing_id IN (SELECT id FROM public_listings WHERE paused_at IS NULL)
+     LIMIT 1`);
+    const row = resultRows(res)[0];
+    if (!row?.image_repository || !row.image_digest)
+        return null;
+    return { imageRepository: row.image_repository, imageDigest: row.image_digest };
+}
+function reviewOrder(sort) {
+    switch (sort) {
+        case 'recent': return sql `created_at DESC, id ASC`;
+        case 'highest': return sql `rating DESC, helpful_count DESC, created_at DESC, id ASC`;
+        case 'lowest': return sql `rating ASC, helpful_count DESC, created_at DESC, id ASC`;
+        case 'helpful':
+        default:
+            // Verified use breaks ties: an org that runs the plugin knows it best.
+            return sql `helpful_count DESC, verified_use DESC, created_at DESC, id ASC`;
+    }
+}
+export function toPublicReview(row) {
+    return {
+        id: row.id,
+        rating: num(row.rating),
+        title: row.title,
+        bodyHtml: row.body_html,
+        version: row.version,
+        author: row.author_display_name ? { displayName: row.author_display_name } : null,
+        verifiedUse: row.verified_use === true,
+        helpfulCount: num(row.helpful_count),
+        edited: row.edited === true,
+        createdAt: iso(row.created_at),
+        updatedAt: iso(row.updated_at),
+        reply: row.reply_body_html
+            ? {
+                bodyHtml: row.reply_body_html,
+                publisherDisplayName: row.publisher_display_name,
+                createdAt: iso(row.reply_created_at),
+                updatedAt: iso(row.reply_updated_at),
+            }
+            : null,
+    };
+}
+/**
+ * One page of a listing's published reviews (the directory's Reviews tab), or null
+ * when the listing isn't public. Held and removed reviews never reach the view.
+ */
+export async function listPublicReviews(publisherHandle, name, query = {}) {
+    const db = getPublicReaderDb();
+    const listing = resultRows(await db.execute(sql `
+    SELECT id FROM public_listings
+     WHERE publisher_handle = ${publisherHandle} AND name = ${name} AND paused_at IS NULL
+     LIMIT 1`))[0];
+    if (!listing)
+        return null;
+    const sort = query.sort && REVIEW_SORTS.includes(query.sort) ? query.sort : 'helpful';
+    const limit = !query.limit || !Number.isFinite(query.limit)
+        ? REVIEWS_DEFAULT_LIMIT
+        : Math.min(Math.max(Math.trunc(query.limit), 1), REVIEWS_MAX_LIMIT);
+    const offset = decodeOffsetCursor(query.cursor);
+    const where = [sql `listing_id = ${listing.id}`];
+    if (query.rating !== undefined && Number.isInteger(query.rating) && query.rating >= 1 && query.rating <= 5) {
+        where.push(sql `rating = ${query.rating}`);
+    }
+    const rows = resultRows(await db.execute(sql `
+    SELECT id, version, rating, title, body_html, author_display_name, verified_use, helpful_count, edited,
+           created_at, updated_at, publisher_display_name, reply_body_html, reply_created_at, reply_updated_at,
+           COUNT(*) OVER () AS total
+      FROM public_reviews
+     WHERE ${sql.join(where, sql ` AND `)}
+     ORDER BY ${reviewOrder(sort)}
+     LIMIT ${limit} OFFSET ${offset}`));
+    const total = rows.length > 0 ? num(rows[0].total) : 0;
+    return {
+        reviews: rows.map(toPublicReview),
+        total,
+        nextCursor: offset + rows.length < total ? encodeOffsetCursor(offset + rows.length) : null,
+    };
+}
+/** Every public listing's URL parts + last update, for the sitemap. */
+export async function listPublicListingsForSitemap(max = 5000) {
+    const db = getPublicReaderDb();
+    const res = await db.execute(sql `
+    SELECT publisher_handle, name, updated_at FROM public_listings
+     WHERE paused_at IS NULL ORDER BY updated_at DESC LIMIT ${Math.min(Math.max(max, 1), 50_000)}`);
+    return resultRows(res)
+        .map((r) => ({ publisher: r.publisher_handle, name: r.name, updatedAt: iso(r.updated_at) }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-directory.js","sourceRoot":"","sources":["../../src/api/public-directory.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Queries behind the anonymous public plugin directory\n * (docs/plugin-publishing.md).\n *\n * Every query here reads ONLY the `public_listings`, `public_listed_versions`,\n * `public_advisories` and `public_reviews` views, through the `ecosystem_public_reader`\n * connection ({@link getPublicReaderDb}). Those views already filter to public\n * rows (listed/unmaintained listings of non-suspended publishers, non-paused\n * versions, published advisories) and project public columns only, so nothing\n * here needs — or has — a tenant context.\n *\n * Search: Postgres full-text (`search_vector`, weighted name A / keywords and\n * category B / summary C / README D, `english` config) OR a trigram match on the\n * name (typo tolerance), ranked by `ts_rank` + name similarity, blended with the\n * Bayesian rating and install count when present. Paused listings are hidden.\n */\n\nimport { sql, type SQL } from 'drizzle-orm';\n\nimport { advisoryRangeCovers } from './plugin-resolution.js';\nimport { compareSemver } from './semver-range.js';\nimport { resultRows } from '../database/pg-result.js';\nimport { getPublicReaderDb } from '../database/public-reader.js';\n\n// -----------------------------------------------------------------------------\n// Public contract (mirrors frontend/src/lib/public-directory/types.ts)\n// -----------------------------------------------------------------------------\n\nexport type DirectoryTrustTier = 'official' | 'verified' | 'community' | 'unverified';\nexport type DirectoryIconKind = 'vendor' | 'uploaded' | 'monogram' | 'category';\nexport type DirectorySort = 'relevance' | 'rating' | 'installs' | 'updated' | 'name' | 'health';\n\nexport const DIRECTORY_SORTS: readonly DirectorySort[] = ['relevance', 'rating', 'installs', 'updated', 'name', 'health'];\n\n/** Per-component health scores: `{ score: 0..1 | null (missing), weight }`. */\nexport type DirectoryHealthBreakdown = Record<string, { score: number | null; weight: number }>;\nexport const DIRECTORY_TIERS: readonly DirectoryTrustTier[] = ['official', 'verified', 'community', 'unverified'];\n\n/** Minimum `word_similarity(query, name)` for a fuzzy name match (typo tolerance). */\nexport const FUZZY_NAME_THRESHOLD = 0.3;\n\n/** Max query length accepted (longer is truncated, never an error). */\nexport const DIRECTORY_MAX_QUERY_LENGTH = 100;\nexport const DIRECTORY_DEFAULT_LIMIT = 24;\nexport const DIRECTORY_MAX_LIMIT = 60;\n\nexport interface DirectorySearchParams {\n  q?: string;\n  category?: string;\n  tier?: DirectoryTrustTier;\n  license?: string;\n  computeType?: string;\n  needsSecrets?: boolean;\n  minRating?: number;\n  sort?: DirectorySort;\n  cursor?: string;\n  limit?: number;\n}\n\nexport interface DirectoryListingCard {\n  publisher: { handle: string; displayName: string; tier: DirectoryTrustTier };\n  name: string;\n  summary: string;\n  category: string;\n  keywords: string[];\n  latestVersion: string;\n  license: string;\n  iconUrl: string | null;\n  iconKind: DirectoryIconKind;\n  iconKey: string | null;\n  iconHex: string | null;\n  iconBadge: string | null;\n  rating: { score: number; count: number } | null;\n  installCount: number;\n  /** 0–100 health score; null when fewer than three components are known. */\n  healthScore: number | null;\n  updatedAt: string;\n  state: 'listed' | 'unmaintained';\n  highlight?: { name?: string; summary?: string };\n}\n\nexport interface DirectorySearchResult {\n  items: DirectoryListingCard[];\n  facets: {\n    category: Record<string, number>;\n    tier: Record<string, number>;\n    license: Record<string, number>;\n    computeType: Record<string, number>;\n    needsSecrets: { true: number; false: number };\n  };\n  total: number;\n  nextCursor: string | null;\n}\n\nexport interface DirectoryCategorySummary {\n  id: string;\n  count: number;\n  top: DirectoryListingCard[];\n}\n\nexport interface DirectoryListingVersion {\n  version: string;\n  publishedAt: string;\n  breaking: boolean;\n  deprecated: boolean;\n  deprecationMessage: string | null;\n  yanked: boolean;\n  changelog: string | null;\n  vulnCritical: number | null;\n  vulnHigh: number | null;\n  scannedAt: string | null;\n  /** Ids of the published advisories whose range covers this version. */\n  advisoryIds: string[];\n}\n\nexport interface DirectoryListingDetail extends DirectoryListingCard {\n  readmeHtml: string | null;\n  description: string;\n  homepageUrl: string | null;\n  sourceUrl: string | null;\n  versions: DirectoryListingVersion[];\n  configuration: {\n    secrets: { name: string; required: boolean; description: string }[];\n    requiredMetadata: string[];\n    requiredVars: string[];\n    computeType: string;\n    primaryOutputDirectory: string | null;\n    networkEgress: string[];\n    pluginType: string;\n  };\n  supplyChain: {\n    signed: boolean;\n    digest: string | null;\n    imageSource: string | null;\n    scannedAt: string | null;\n    vulnCritical: number | null;\n    vulnHigh: number | null;\n    sbomUrl: string | null;\n  };\n  advisories: {\n    id: string;\n    severity: string;\n    summary: string;\n    affectedRange: string;\n    fixedVersion: string | null;\n    publishedAt: string;\n    /** Server-sanitized HTML (the stored render of the details markdown). */\n    detailsHtml: string | null;\n    cveIds: string[];\n  }[];\n  ratingDistribution: Record<'1' | '2' | '3' | '4' | '5', number> | null;\n  /** The Bayesian rating over reviews of the last two minor versions. */\n  recentRating: number | null;\n  activeOrgCount: number | null;\n  /** Per-component health scores behind {@link DirectoryListingCard.healthScore}. */\n  healthBreakdown: DirectoryHealthBreakdown | null;\n  /** 30-day runtime success rate (0..1), or null with no runs. */\n  successRate30d: number | null;\n}\n\nexport type ReviewSort = 'helpful' | 'recent' | 'highest' | 'lowest';\nexport const REVIEW_SORTS: readonly ReviewSort[] = ['helpful', 'recent', 'highest', 'lowest'];\nexport const REVIEWS_DEFAULT_LIMIT = 10;\nexport const REVIEWS_MAX_LIMIT = 50;\n\nexport interface PublicReviewReply {\n  bodyHtml: string;\n  publisherDisplayName: string;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/** One published review as the directory shows it: display name only, never an org. */\nexport interface PublicReviewItem {\n  id: string;\n  rating: number;\n  title: string | null;\n  bodyHtml: string | null;\n  version: string | null;\n  /** Null once the author's account was deleted (the review is anonymized). */\n  author: { displayName: string } | null;\n  verifiedUse: boolean;\n  helpfulCount: number;\n  edited: boolean;\n  createdAt: string;\n  updatedAt: string;\n  reply: PublicReviewReply | null;\n}\n\nexport interface PublicReviewPage {\n  reviews: PublicReviewItem[];\n  total: number;\n  nextCursor: string | null;\n}\n\nexport interface PublicReviewQuery {\n  sort?: ReviewSort;\n  /** Only reviews with exactly this many stars. */\n  rating?: number;\n  cursor?: string;\n  limit?: number;\n}\n\n// -----------------------------------------------------------------------------\n// Row mapping\n// -----------------------------------------------------------------------------\n\n/** A `public_listings` row as the raw queries return it (snake_case). */\nexport interface PublicListingRow {\n  id: string;\n  publisher_handle: string;\n  publisher_display_name: string;\n  publisher_tier: DirectoryTrustTier;\n  name: string;\n  category: string;\n  summary: string | null;\n  description: string | null;\n  readme_html: string | null;\n  license: string | null;\n  homepage_url: string | null;\n  source_url: string | null;\n  icon: { key: string; badge?: string } | null;\n  uploaded_icon: { key256: string; key64: string } | null;\n  keywords: string[] | null;\n  latest_version: string | null;\n  updated_at: Date | string;\n  rating_bayes: number | string | null;\n  rating_count: number | string;\n  rating_dist: Record<string, number> | null;\n  recent_rating?: number | string | null;\n  install_count: number | string;\n  active_org_count: number | string | null;\n  health_score?: number | string | null;\n  health_breakdown?: DirectoryHealthBreakdown | null;\n  success_rate_30d?: number | string | null;\n  state: 'listed' | 'unmaintained';\n}\n\nfunction num(v: number | string | null | undefined): number {\n  const n = typeof v === 'number' ? v : Number.parseFloat(String(v ?? '0'));\n  return Number.isFinite(n) ? n : 0;\n}\n\nfunction iso(v: Date | string | null | undefined): string {\n  if (!v) return '';\n  return v instanceof Date ? v.toISOString() : new Date(v).toISOString();\n}\n\n/**\n * The icon fallback chain: uploaded (if the tier may upload) → curated\n * vendor key (Official, and Verified publishers for marks they own — ownership\n * is checked when the icon is approved) → monogram. Community and anonymous\n * listings can never show a curated vendor mark.\n */\nexport function resolveListingIcon(row: Pick<PublicListingRow, 'publisher_tier' | 'icon' | 'uploaded_icon'>): Pick<\n  DirectoryListingCard, 'iconKind' | 'iconUrl' | 'iconKey' | 'iconBadge' | 'iconHex'\n> {\n  const none = { iconUrl: null, iconKey: null, iconBadge: null, iconHex: null };\n  if (row.uploaded_icon?.key256) {\n    return { ...none, iconKind: 'uploaded', iconUrl: `/api/public/plugins/icons/${encodeURIComponent(row.uploaded_icon.key256)}` };\n  }\n  const curatedAllowed = row.publisher_tier === 'official' || row.publisher_tier === 'verified';\n  if (curatedAllowed && row.icon?.key) {\n    return { ...none, iconKind: 'vendor', iconKey: row.icon.key, iconBadge: row.icon.badge ?? null };\n  }\n  return { ...none, iconKind: 'monogram' };\n}\n\nexport function toListingCard(row: PublicListingRow): DirectoryListingCard {\n  const ratingCount = num(row.rating_count);\n  return {\n    publisher: { handle: row.publisher_handle, displayName: row.publisher_display_name, tier: row.publisher_tier },\n    name: row.name,\n    summary: row.summary ?? '',\n    category: row.category,\n    keywords: row.keywords ?? [],\n    latestVersion: row.latest_version ?? '',\n    license: row.license ?? '',\n    ...resolveListingIcon(row),\n    rating: ratingCount > 0 && row.rating_bayes != null ? { score: Math.round(num(row.rating_bayes) * 100) / 100, count: ratingCount } : null,\n    installCount: num(row.install_count),\n    healthScore: row.health_score == null ? null : Math.round(num(row.health_score)),\n    updatedAt: iso(row.updated_at),\n    state: row.state,\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Search\n// -----------------------------------------------------------------------------\n\n/** Normalize the user's query: collapse whitespace, cap the length. */\nexport function normalizeQuery(q: string | undefined): string {\n  return (q ?? '').replace(/\\s+/g, ' ').trim().slice(0, DIRECTORY_MAX_QUERY_LENGTH);\n}\n\n/** Search terms for highlighting: words of ≥ 2 characters, regex-escaped. */\nfunction highlightTerms(q: string): string[] {\n  return [...new Set(q.toLowerCase().split(/[^a-z0-9._-]+/).filter((t) => t.length >= 2))]\n    .map((t) => t.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'));\n}\n\n/**\n * Wrap matched terms in `<mark>`. The frontend renders everything except the\n * `<mark>` markers as TEXT (never HTML), so the source text is not escaped here.\n * Returns undefined when nothing matched (the card then renders plain text).\n */\nexport function highlightText(text: string, q: string): string | undefined {\n  const terms = highlightTerms(q);\n  if (!text || terms.length === 0) return undefined;\n  const re = new RegExp(`(${terms.join('|')})`, 'gi');\n  if (!re.test(text)) return undefined;\n  return text.replace(re, '<mark>$1</mark>');\n}\n\n/** Opaque cursor: an offset, base64url-encoded so clients don't depend on it. */\nexport function encodeOffsetCursor(offset: number): string {\n  return Buffer.from(JSON.stringify({ o: offset })).toString('base64url');\n}\n\nexport function decodeOffsetCursor(cursor: string | undefined): number {\n  if (!cursor) return 0;\n  try {\n    const o = (JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8')) as { o?: unknown }).o;\n    return typeof o === 'number' && Number.isInteger(o) && o >= 0 && o <= 10_000 ? o : 0;\n  } catch {\n    return 0;\n  }\n}\n\nfunction clampLimit(limit: number | undefined): number {\n  if (!limit || !Number.isFinite(limit)) return DIRECTORY_DEFAULT_LIMIT;\n  return Math.min(Math.max(Math.trunc(limit), 1), DIRECTORY_MAX_LIMIT);\n}\n\n/**\n * The filtered base set as a CTE body. Every search, facet and category query\n * reads through this, so they can't disagree about what's visible.\n */\nfunction baseQuery(params: DirectorySearchParams, q: string): SQL {\n  const where: SQL[] = [sql`l.paused_at IS NULL`];\n  if (q) {\n    // Full text, OR a fuzzy match against the best-matching PART of the name\n    // (word_similarity: \"terafrom\" → terraform-plan scores 0.36, while unrelated\n    // words stay ≤ 0.2 — whole-name similarity() dilutes a long name below any\n    // useful threshold). Explicit function, not the `<%` operator, so the cut-off\n    // doesn't depend on a session GUC pgbouncer can't carry. A seq scan over the\n    // public listings (thousands of rows at most) is fine.\n    where.push(sql`(l.search_vector @@ websearch_to_tsquery('english', ${q}) OR word_similarity(${q}, l.name) >= ${FUZZY_NAME_THRESHOLD} OR l.name ILIKE ${`%${q.replace(/[\\\\%_]/g, '\\\\$&')}%`})`);\n  }\n  if (params.category) where.push(sql`l.category = ${params.category}`);\n  if (params.tier) where.push(sql`l.publisher_tier = ${params.tier}`);\n  if (params.license) where.push(sql`l.license = ${params.license}`);\n  if (params.computeType) where.push(sql`v.compute_type = ${params.computeType}`);\n  if (params.needsSecrets !== undefined) {\n    where.push(params.needsSecrets\n      ? sql`jsonb_array_length(COALESCE(v.secrets, '[]'::jsonb)) > 0`\n      : sql`jsonb_array_length(COALESCE(v.secrets, '[]'::jsonb)) = 0`);\n  }\n  if (params.minRating !== undefined && Number.isFinite(params.minRating)) {\n    where.push(sql`l.rating_bayes >= ${params.minRating}`);\n  }\n  const rank = q\n    ? sql`(ts_rank(l.search_vector, websearch_to_tsquery('english', ${q})) + word_similarity(${q}, l.name))`\n    : sql`0::real`;\n  return sql`\n    SELECT l.id, l.publisher_handle, l.publisher_display_name, l.publisher_tier, l.name, l.category,\n           l.summary, l.description, l.readme_html, l.license, l.homepage_url, l.source_url, l.icon,\n           l.uploaded_icon, l.keywords, l.latest_version, l.updated_at, l.rating_bayes, l.rating_count,\n           l.rating_dist, l.install_count, l.active_org_count, l.health_score, l.state,\n           v.compute_type,\n           (jsonb_array_length(COALESCE(v.secrets, '[]'::jsonb)) > 0) AS needs_secrets,\n           ${rank} AS rank\n      FROM public_listings l\n      LEFT JOIN LATERAL (\n        SELECT pv.compute_type, pv.secrets\n          FROM public_listed_versions pv\n         WHERE pv.listing_id = l.id AND pv.version = l.latest_version AND NOT pv.yanked\n         LIMIT 1\n      ) v ON true\n     WHERE ${sql.join(where, sql` AND `)}`;\n}\n\nfunction orderBy(sort: DirectorySort, hasQuery: boolean): SQL {\n  switch (sort === 'relevance' && !hasQuery ? 'updated' : sort) {\n    case 'relevance':\n      // Text relevance first, nudged by rating and adoption so equal matches\n      // favour proven plugins.\n      return sql`(rank * (1 + COALESCE(rating_bayes, 0) / 10) + ln(1 + install_count) / 20) DESC, name ASC`;\n    case 'rating':\n      return sql`rating_bayes DESC NULLS LAST, rating_count DESC, name ASC`;\n    case 'installs':\n      return sql`install_count DESC, name ASC`;\n    case 'name':\n      return sql`name ASC, publisher_handle ASC`;\n    case 'health':\n      return sql`health_score DESC NULLS LAST, install_count DESC, name ASC`;\n    case 'updated':\n    default:\n      return sql`updated_at DESC, name ASC`;\n  }\n}\n\n/** Search the directory: one page of cards, facet counts, total and next cursor. */\nexport async function searchPublicListings(params: DirectorySearchParams): Promise<DirectorySearchResult> {\n  const db = getPublicReaderDb();\n  const q = normalizeQuery(params.q);\n  const limit = clampLimit(params.limit);\n  const offset = decodeOffsetCursor(params.cursor);\n  const sort = params.sort && DIRECTORY_SORTS.includes(params.sort) ? params.sort : 'relevance';\n  const base = baseQuery(params, q);\n\n  const [pageRes, facetRes] = await Promise.all([\n    db.execute(sql`\n      WITH base AS (${base})\n      SELECT base.*, COUNT(*) OVER () AS total\n        FROM base\n       ORDER BY ${orderBy(sort, q !== '')}\n       LIMIT ${limit} OFFSET ${offset}`),\n    db.execute(sql`\n      WITH base AS (${base})\n      SELECT category, publisher_tier, license, compute_type, needs_secrets,\n             GROUPING(category) AS g_category, GROUPING(publisher_tier) AS g_tier,\n             GROUPING(license) AS g_license, GROUPING(compute_type) AS g_compute,\n             GROUPING(needs_secrets) AS g_secrets,\n             COUNT(*) AS n\n        FROM base\n       GROUP BY GROUPING SETS ((category), (publisher_tier), (license), (compute_type), (needs_secrets))`),\n  ]);\n\n  const page = resultRows<PublicListingRow & { total: number | string }>(pageRes);\n  const total = page.length > 0 ? num(page[0]!.total) : 0;\n  const items = page.map((row) => {\n    const card = toListingCard(row);\n    if (q) {\n      const highlight = { name: highlightText(card.name, q), summary: highlightText(card.summary, q) };\n      if (highlight.name || highlight.summary) card.highlight = highlight;\n    }\n    return card;\n  });\n\n  const facets: DirectorySearchResult['facets'] = {\n    category: {}, tier: {}, license: {}, computeType: {}, needsSecrets: { true: 0, false: 0 },\n  };\n  type FacetRow = {\n    category: string | null;\n    publisher_tier: string | null;\n    license: string | null;\n    compute_type: string | null;\n    needs_secrets: boolean | null;\n    g_category: number;\n    g_tier: number;\n    g_license: number;\n    g_compute: number;\n    g_secrets: number;\n    n: number | string;\n  };\n  for (const r of resultRows<FacetRow>(facetRes)) {\n    const n = num(r.n);\n    if (Number(r.g_category) === 0 && r.category) facets.category[r.category] = n;\n    else if (Number(r.g_tier) === 0 && r.publisher_tier) facets.tier[r.publisher_tier] = n;\n    else if (Number(r.g_license) === 0 && r.license) facets.license[r.license] = n;\n    else if (Number(r.g_compute) === 0 && r.compute_type) facets.computeType[r.compute_type] = n;\n    else if (Number(r.g_secrets) === 0 && r.needs_secrets !== null) facets.needsSecrets[r.needs_secrets ? 'true' : 'false'] = n;\n  }\n\n  return {\n    items,\n    facets,\n    total,\n    nextCursor: offset + items.length < total ? encodeOffsetCursor(offset + items.length) : null,\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Categories\n// -----------------------------------------------------------------------------\n\n/** Every category with its live count and its top listings (by rating, then installs). */\nexport async function listPublicCategories(topPerCategory = 3): Promise<DirectoryCategorySummary[]> {\n  const db = getPublicReaderDb();\n  const res = await db.execute(sql`\n    WITH ranked AS (\n      SELECT l.*,\n             ROW_NUMBER() OVER (PARTITION BY l.category\n                                ORDER BY l.rating_bayes DESC NULLS LAST, l.install_count DESC, l.name ASC) AS rn,\n             COUNT(*) OVER (PARTITION BY l.category) AS category_count\n        FROM public_listings l\n       WHERE l.paused_at IS NULL\n    )\n    SELECT * FROM ranked WHERE rn <= ${Math.max(0, Math.min(topPerCategory, 10))} ORDER BY category ASC, rn ASC`);\n\n  const byCategory = new Map<string, DirectoryCategorySummary>();\n  for (const row of resultRows<PublicListingRow & { category_count: number | string }>(res)) {\n    let summary = byCategory.get(row.category);\n    if (!summary) {\n      summary = { id: row.category, count: num(row.category_count), top: [] };\n      byCategory.set(row.category, summary);\n    }\n    summary.top.push(toListingCard(row));\n  }\n  return [...byCategory.values()];\n}\n\n// -----------------------------------------------------------------------------\n// One listing\n// -----------------------------------------------------------------------------\n\ntype VersionRow = {\n  version: string;\n  published_at: Date | string;\n  breaking: boolean;\n  deprecated_at: Date | string | null;\n  deprecation_message: string | null;\n  yanked: boolean;\n  changelog: string | null;\n  vuln_critical: number | null;\n  vuln_high: number | null;\n  scanned_at: Date | string | null;\n  image_digest: string | null;\n  image_source: string | null;\n  plugin_type: string | null;\n  compute_type: string | null;\n  secrets: { name: string; required: boolean; description?: string }[] | null;\n  required_metadata: string[] | null;\n  required_vars: string[] | null;\n  network_egress: string[] | null;\n  readme_html: string | null;\n};\n\ntype AdvisoryRow = {\n  id: string;\n  severity: string;\n  summary: string;\n  affected_range: string;\n  fixed_version: string | null;\n  published_at: Date | string | null;\n  details_html: string | null;\n  cve_ids: string[] | null;\n};\n\n/**\n * One listing's page data, or null when it isn't public (unknown, suspended,\n * transferred, paused by its publisher — or its publisher is suspended).\n */\nexport async function getPublicListing(publisherHandle: string, name: string): Promise<DirectoryListingDetail | null> {\n  const db = getPublicReaderDb();\n  const listingRes = await db.execute(sql`\n    SELECT * FROM public_listings\n     WHERE publisher_handle = ${publisherHandle} AND name = ${name} AND paused_at IS NULL\n     LIMIT 1`);\n  const row = resultRows<PublicListingRow>(listingRes)[0];\n  if (!row) return null;\n\n  const [versionRes, advisoryRes] = await Promise.all([\n    db.execute(sql`SELECT * FROM public_listed_versions WHERE listing_id = ${row.id}`),\n    db.execute(sql`SELECT * FROM public_advisories WHERE listing_id = ${row.id} ORDER BY published_at DESC`),\n  ]);\n  const versionRows = resultRows<VersionRow>(versionRes).sort((a, b) => compareSemver(b.version, a.version));\n  const advisoryRows = resultRows<AdvisoryRow>(advisoryRes);\n  // The version the page describes: the listing's latest, else the newest non-yanked one.\n  const current = versionRows.find((v) => v.version === row.latest_version && !v.yanked)\n    ?? versionRows.find((v) => !v.yanked)\n    ?? null;\n\n  const dist = row.rating_dist ?? null;\n  const card = toListingCard(row);\n  return {\n    ...card,\n    readmeHtml: row.readme_html ?? current?.readme_html ?? null,\n    description: row.description ?? '',\n    homepageUrl: row.homepage_url,\n    sourceUrl: row.source_url,\n    versions: versionRows.map((v) => ({\n      version: v.version,\n      publishedAt: iso(v.published_at),\n      breaking: v.breaking,\n      deprecated: v.deprecated_at != null,\n      deprecationMessage: v.deprecation_message,\n      yanked: v.yanked,\n      changelog: v.changelog,\n      vulnCritical: v.vuln_critical,\n      vulnHigh: v.vuln_high,\n      scannedAt: v.scanned_at ? iso(v.scanned_at) : null,\n      advisoryIds: advisoryRows.filter((a) => advisoryRangeCovers(a.affected_range, v.version)).map((a) => a.id),\n    })),\n    configuration: {\n      secrets: (current?.secrets ?? []).map((s) => ({ name: s.name, required: s.required, description: s.description ?? '' })),\n      requiredMetadata: current?.required_metadata ?? [],\n      requiredVars: current?.required_vars ?? [],\n      computeType: current?.compute_type ?? '',\n      primaryOutputDirectory: null,\n      networkEgress: current?.network_egress ?? [],\n      pluginType: current?.plugin_type ?? '',\n    },\n    supplyChain: {\n      // A listed version exists only after the platform re-signed it in public/*.\n      signed: current?.image_digest != null,\n      digest: current?.image_digest ?? null,\n      imageSource: current?.image_source ?? null,\n      scannedAt: current?.scanned_at ? iso(current.scanned_at) : null,\n      vulnCritical: current?.vuln_critical ?? null,\n      vulnHigh: current?.vuln_high ?? null,\n      sbomUrl: current?.image_digest\n        ? `/api/public/plugins/${encodeURIComponent(row.publisher_handle)}/${encodeURIComponent(row.name)}/versions/${encodeURIComponent(current.version)}/sbom`\n        : null,\n    },\n    advisories: advisoryRows.map((a) => ({\n      id: a.id,\n      severity: a.severity,\n      summary: a.summary,\n      affectedRange: a.affected_range,\n      fixedVersion: a.fixed_version,\n      publishedAt: iso(a.published_at),\n      detailsHtml: a.details_html,\n      cveIds: a.cve_ids ?? [],\n    })),\n    ratingDistribution: dist\n      ? { 1: num(dist['1']), 2: num(dist['2']), 3: num(dist['3']), 4: num(dist['4']), 5: num(dist['5']) }\n      : null,\n    recentRating: row.recent_rating == null ? null : Math.round(num(row.recent_rating) * 100) / 100,\n    activeOrgCount: row.active_org_count == null ? null : num(row.active_org_count),\n    healthBreakdown: row.health_breakdown ?? null,\n    successRate30d: row.success_rate_30d == null ? null : Math.round(num(row.success_rate_30d) * 1000) / 1000,\n  };\n}\n\n/** One listed version's public image identity (for the SBOM download), or null. */\nexport async function getPublicListedVersion(\n  publisherHandle: string, name: string, version: string,\n): Promise<{ imageRepository: string; imageDigest: string } | null> {\n  const db = getPublicReaderDb();\n  const res = await db.execute(sql`\n    SELECT image_repository, image_digest FROM public_listed_versions\n     WHERE publisher_handle = ${publisherHandle} AND name = ${name} AND version = ${version} AND NOT yanked\n       AND listing_id IN (SELECT id FROM public_listings WHERE paused_at IS NULL)\n     LIMIT 1`);\n  const row = resultRows<{ image_repository: string | null; image_digest: string | null }>(res)[0];\n  if (!row?.image_repository || !row.image_digest) return null;\n  return { imageRepository: row.image_repository, imageDigest: row.image_digest };\n}\n\n// -----------------------------------------------------------------------------\n// Reviews\n// -----------------------------------------------------------------------------\n\ntype ReviewRow = {\n  id: string;\n  version: string | null;\n  rating: number | string;\n  title: string | null;\n  body_html: string | null;\n  author_display_name: string | null;\n  verified_use: boolean;\n  helpful_count: number | string;\n  edited: boolean;\n  created_at: Date | string;\n  updated_at: Date | string;\n  publisher_display_name: string;\n  reply_body_html: string | null;\n  reply_created_at: Date | string | null;\n  reply_updated_at: Date | string | null;\n  total: number | string;\n};\n\nfunction reviewOrder(sort: ReviewSort): SQL {\n  switch (sort) {\n    case 'recent': return sql`created_at DESC, id ASC`;\n    case 'highest': return sql`rating DESC, helpful_count DESC, created_at DESC, id ASC`;\n    case 'lowest': return sql`rating ASC, helpful_count DESC, created_at DESC, id ASC`;\n    case 'helpful':\n    default:\n      // Verified use breaks ties: an org that runs the plugin knows it best.\n      return sql`helpful_count DESC, verified_use DESC, created_at DESC, id ASC`;\n  }\n}\n\nexport function toPublicReview(row: Omit<ReviewRow, 'total'>): PublicReviewItem {\n  return {\n    id: row.id,\n    rating: num(row.rating),\n    title: row.title,\n    bodyHtml: row.body_html,\n    version: row.version,\n    author: row.author_display_name ? { displayName: row.author_display_name } : null,\n    verifiedUse: row.verified_use === true,\n    helpfulCount: num(row.helpful_count),\n    edited: row.edited === true,\n    createdAt: iso(row.created_at),\n    updatedAt: iso(row.updated_at),\n    reply: row.reply_body_html\n      ? {\n        bodyHtml: row.reply_body_html,\n        publisherDisplayName: row.publisher_display_name,\n        createdAt: iso(row.reply_created_at),\n        updatedAt: iso(row.reply_updated_at),\n      }\n      : null,\n  };\n}\n\n/**\n * One page of a listing's published reviews (the directory's Reviews tab), or null\n * when the listing isn't public. Held and removed reviews never reach the view.\n */\nexport async function listPublicReviews(publisherHandle: string, name: string, query: PublicReviewQuery = {}): Promise<PublicReviewPage | null> {\n  const db = getPublicReaderDb();\n  const listing = resultRows<{ id: string }>(await db.execute(sql`\n    SELECT id FROM public_listings\n     WHERE publisher_handle = ${publisherHandle} AND name = ${name} AND paused_at IS NULL\n     LIMIT 1`))[0];\n  if (!listing) return null;\n\n  const sort = query.sort && REVIEW_SORTS.includes(query.sort) ? query.sort : 'helpful';\n  const limit = !query.limit || !Number.isFinite(query.limit)\n    ? REVIEWS_DEFAULT_LIMIT\n    : Math.min(Math.max(Math.trunc(query.limit), 1), REVIEWS_MAX_LIMIT);\n  const offset = decodeOffsetCursor(query.cursor);\n  const where: SQL[] = [sql`listing_id = ${listing.id}`];\n  if (query.rating !== undefined && Number.isInteger(query.rating) && query.rating >= 1 && query.rating <= 5) {\n    where.push(sql`rating = ${query.rating}`);\n  }\n  const rows = resultRows<ReviewRow>(await db.execute(sql`\n    SELECT id, version, rating, title, body_html, author_display_name, verified_use, helpful_count, edited,\n           created_at, updated_at, publisher_display_name, reply_body_html, reply_created_at, reply_updated_at,\n           COUNT(*) OVER () AS total\n      FROM public_reviews\n     WHERE ${sql.join(where, sql` AND `)}\n     ORDER BY ${reviewOrder(sort)}\n     LIMIT ${limit} OFFSET ${offset}`));\n  const total = rows.length > 0 ? num(rows[0]!.total) : 0;\n  return {\n    reviews: rows.map(toPublicReview),\n    total,\n    nextCursor: offset + rows.length < total ? encodeOffsetCursor(offset + rows.length) : null,\n  };\n}\n\n/** Every public listing's URL parts + last update, for the sitemap. */\nexport async function listPublicListingsForSitemap(max = 5000): Promise<{ publisher: string; name: string; updatedAt: string }[]> {\n  const db = getPublicReaderDb();\n  const res = await db.execute(sql`\n    SELECT publisher_handle, name, updated_at FROM public_listings\n     WHERE paused_at IS NULL ORDER BY updated_at DESC LIMIT ${Math.min(Math.max(max, 1), 50_000)}`);\n  return resultRows<{ publisher_handle: string; name: string; updated_at: Date | string }>(res)\n    .map((r) => ({ publisher: r.publisher_handle, name: r.name, updatedAt: iso(r.updated_at) }));\n}\n"]}

package/lib/api/query-builders.d.ts

@@ -14,6 +14,19 @@ import type { MessageFilter, PipelineFilter, PipelineTemplateFilter, PluginFilte
  * @returns Array of SQL conditions
  */
 export declare function buildPipelineConditions(filter: Partial<PipelineFilter>, orgId?: string, parentOrgId?: string): SQL[];
+/**
+ * THE ranking for resolving one plugin ROW by name (`/plugins/lookup`,
+ * `/plugins/find`, the pipeline service's contract check) — one definition so
+ * synth and the contract check never pick different winners. Rows are only the
+ * org's own and its parent's: the Official catalog and every other publisher
+ * resolve as LISTINGS afterwards (plugin-resolution.ts).
+ *   1. owner — the caller's own org, then its parent org (a team reads the
+ *      parent's shared rows), then anything else a superadmin can see;
+ *   2. the default version;
+ *   3. the highest semver (so `^1.2` resolves to the newest matching release);
+ *   4. `id`, a total tiebreak.
+ */
+export declare function pluginResolutionOrderBy(orgId?: string, parentOrgId?: string): SQL[];
 /**
  * Build SQL conditions for plugin queries
  *