@pipeline-builder/pipeline-data 4.1.15 → 4.1.17

package/lib/api/semver-range.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Version specs for plugin lookups (docs/plugin-installing.md).
+ *
+ * A small, dependency-free matcher for exactly the forms plugin references use:
+ *
+ *   exact    `1.2.3`, `1.2.3-rc.1`   that one version
+ *   caret    `^1.2.3`                >=1.2.3 <2.0.0  (`^0.2.3` <0.3.0, `^0.0.3` <0.0.4)
+ *            `^1`, `^1.2`            >=1.0.0 <2.0.0, >=1.2.0 <2.0.0  (`^0.2` <0.3.0, `^0` <1.0.0)
+ *   tilde    `~1.2.3`                >=1.2.3 <1.3.0
+ *            `~1`, `~1.2`            >=1.0.0 <2.0.0, >=1.2.0 <1.3.0
+ *   partial  `1`, `1.x`, `1.2`, `1.2.x`  >=1.0.0 <2.0.0 / >=1.2.0 <1.3.0
+ *   latest   `latest`                the highest stable version
+ *
+ * npm semantics throughout, including prereleases: a range never matches a
+ * prerelease unless its own lower bound is a prerelease of the SAME
+ * major.minor.patch (so `^1.2.3-beta.1` admits `1.2.3-beta.2` but not
+ * `1.3.0-beta.1`). An exact spec may name a prerelease directly.
+ *
+ * The matcher runs in JS ({@link satisfiesVersionSpec}) and — for the query
+ * builders — as SQL over the `version` column ({@link versionSpecCondition},
+ * {@link semverOrderBy}); the two are kept equivalent by the shared tests.
+ */
+import { SQL } from 'drizzle-orm';
+import type { AnyColumn } from 'drizzle-orm/column';
+/** A parsed `major.minor.patch[-prerelease][+build]` version. */
+export interface SemverParts {
+    major: number;
+    minor: number;
+    patch: number;
+    /** Dot-separated prerelease identifiers; empty for a stable version. */
+    prerelease: string[];
+}
+/** A parsed version spec. `range` bounds are `[min, max)`. */
+export type VersionSpec = {
+    kind: 'exact';
+    version: string;
+} | {
+    kind: 'latest';
+} | {
+    kind: 'range';
+    min: SemverParts;
+    max: SemverParts;
+};
+/** Parse a full semver string, or `null` when it isn't one. */
+export declare function parseSemver(version: string): SemverParts | null;
+/** Semver 2.0 precedence: negative when `a < b`, 0 when equal, positive when `a > b`. */
+export declare function compareSemverParts(a: SemverParts, b: SemverParts): number;
+/** {@link compareSemverParts} over strings; unparseable versions sort lowest. */
+export declare function compareSemver(a: string, b: string): number;
+/**
+ * Parse a version spec, or `null` when it is none of the supported forms (the
+ * caller then treats the input as a literal version, which matches nothing).
+ */
+export declare function parseVersionSpec(spec: string): VersionSpec | null;
+/** True when `spec` resolves to a SET of versions (range or `latest`), not one. */
+export declare function isVersionRange(spec: string): boolean;
+/** Whether `version` satisfies `spec` (a string or an already-parsed spec). */
+export declare function satisfiesVersionSpec(version: string, spec: string | VersionSpec): boolean;
+/** The highest of `versions` satisfying `spec`, or `null`. */
+export declare function maxSatisfying(versions: readonly string[], spec: string | VersionSpec): string | null;
+/**
+ * SQL predicate for `col` satisfying `spec`. Precision note: prerelease-vs-
+ * prerelease ordering WITHIN the lower bound's own tuple is not compared in SQL
+ * (every prerelease of that tuple is admitted) — {@link semverOrderBy} still
+ * ranks them, and the JS matcher is exact.
+ */
+export declare function versionSpecCondition(col: AnyColumn, spec: string): SQL;
+/**
+ * ORDER BY terms ranking `col` highest-semver first: numeric major/minor/patch,
+ * a stable version above its prereleases, then the prerelease text (a
+ * lexicographic tiebreak — close to, not exactly, semver identifier order).
+ */
+export declare function semverOrderBy(col: AnyColumn): SQL[];

package/lib/api/semver-range.js

@@ -0,0 +1,227 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Version specs for plugin lookups (docs/plugin-installing.md).
+ *
+ * A small, dependency-free matcher for exactly the forms plugin references use:
+ *
+ *   exact    `1.2.3`, `1.2.3-rc.1`   that one version
+ *   caret    `^1.2.3`                >=1.2.3 <2.0.0  (`^0.2.3` <0.3.0, `^0.0.3` <0.0.4)
+ *            `^1`, `^1.2`            >=1.0.0 <2.0.0, >=1.2.0 <2.0.0  (`^0.2` <0.3.0, `^0` <1.0.0)
+ *   tilde    `~1.2.3`                >=1.2.3 <1.3.0
+ *            `~1`, `~1.2`            >=1.0.0 <2.0.0, >=1.2.0 <1.3.0
+ *   partial  `1`, `1.x`, `1.2`, `1.2.x`  >=1.0.0 <2.0.0 / >=1.2.0 <1.3.0
+ *   latest   `latest`                the highest stable version
+ *
+ * npm semantics throughout, including prereleases: a range never matches a
+ * prerelease unless its own lower bound is a prerelease of the SAME
+ * major.minor.patch (so `^1.2.3-beta.1` admits `1.2.3-beta.2` but not
+ * `1.3.0-beta.1`). An exact spec may name a prerelease directly.
+ *
+ * The matcher runs in JS ({@link satisfiesVersionSpec}) and — for the query
+ * builders — as SQL over the `version` column ({@link versionSpecCondition},
+ * {@link semverOrderBy}); the two are kept equivalent by the shared tests.
+ */
+import { and, asc, desc, eq, or, sql, SQL } from 'drizzle-orm';
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const PARTIAL = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*|x|\*))?(?:\.(x|\*))?$/;
+/** Upper bound on any numeric part (keeps SQL `::int` casts in range). */
+const MAX_PART = 2_147_483_647;
+/** Parse a full semver string, or `null` when it isn't one. */
+export function parseSemver(version) {
+    const m = SEMVER.exec(version.trim());
+    if (!m)
+        return null;
+    const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    if (major > MAX_PART || minor > MAX_PART || patch > MAX_PART)
+        return null;
+    return { major, minor, patch, prerelease: m[4] ? m[4].split('.') : [] };
+}
+function compareIdentifiers(a, b) {
+    const an = /^\d+$/.test(a);
+    const bn = /^\d+$/.test(b);
+    if (an && bn)
+        return Number(a) - Number(b);
+    if (an)
+        return -1; // numeric identifiers sort below alphanumeric ones
+    if (bn)
+        return 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/** Semver 2.0 precedence: negative when `a < b`, 0 when equal, positive when `a > b`. */
+export function compareSemverParts(a, b) {
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    // A stable version outranks any prerelease of the same tuple.
+    if (!a.prerelease.length || !b.prerelease.length)
+        return b.prerelease.length - a.prerelease.length;
+    for (let i = 0; i < Math.max(a.prerelease.length, b.prerelease.length); i++) {
+        if (a.prerelease[i] === undefined)
+            return -1;
+        if (b.prerelease[i] === undefined)
+            return 1;
+        const c = compareIdentifiers(a.prerelease[i], b.prerelease[i]);
+        if (c !== 0)
+            return c;
+    }
+    return 0;
+}
+/** {@link compareSemverParts} over strings; unparseable versions sort lowest. */
+export function compareSemver(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (!pa || !pb)
+        return (pa ? 1 : 0) - (pb ? 1 : 0);
+    return compareSemverParts(pa, pb);
+}
+const parts = (major, minor, patch, prerelease = []) => ({ major, minor, patch, prerelease });
+/**
+ * Parse a version spec, or `null` when it is none of the supported forms (the
+ * caller then treats the input as a literal version, which matches nothing).
+ */
+export function parseVersionSpec(spec) {
+    const s = spec.trim();
+    if (s === 'latest')
+        return { kind: 'latest' };
+    if (s.startsWith('^') || s.startsWith('~')) {
+        const partial = PARTIAL.exec(s.slice(1));
+        if (partial && !parseSemver(s.slice(1)))
+            return partialOperatorRange(s[0], partial);
+        const base = parseSemver(s.slice(1));
+        if (!base)
+            return null;
+        const { major, minor, patch } = base;
+        let max;
+        if (s[0] === '~')
+            max = parts(major, minor + 1, 0);
+        else if (major > 0)
+            max = parts(major + 1, 0, 0);
+        else if (minor > 0)
+            max = parts(0, minor + 1, 0);
+        else
+            max = parts(0, 0, patch + 1);
+        return { kind: 'range', min: base, max };
+    }
+    if (parseSemver(s))
+        return { kind: 'exact', version: s };
+    const m = PARTIAL.exec(s);
+    if (!m)
+        return null;
+    const major = Number(m[1]);
+    const minorWild = m[2] === undefined || m[2] === 'x' || m[2] === '*';
+    if (major > MAX_PART)
+        return null;
+    if (minorWild)
+        return { kind: 'range', min: parts(major, 0, 0), max: parts(major + 1, 0, 0) };
+    const minor = Number(m[2]);
+    if (minor > MAX_PART)
+        return null;
+    return { kind: 'range', min: parts(major, minor, 0), max: parts(major, minor + 1, 0) };
+}
+/**
+ * `^` / `~` over a PARTIAL version (npm): the missing parts are zero, and the
+ * upper bound follows the operator — `^1` / `~1` <2.0.0, `^1.2` <2.0.0 but
+ * `~1.2` <1.3.0, and a zero major narrows a caret to the next minor
+ * (`^0.2` <0.3.0) or major (`^0` <1.0.0).
+ */
+function partialOperatorRange(op, m) {
+    const major = Number(m[1]);
+    const minorGiven = m[2] !== undefined && m[2] !== 'x' && m[2] !== '*';
+    const minor = minorGiven ? Number(m[2]) : 0;
+    if (major > MAX_PART || minor > MAX_PART)
+        return null;
+    const min = parts(major, minor, 0);
+    if (!minorGiven)
+        return { kind: 'range', min, max: parts(major + 1, 0, 0) };
+    if (op === '~' || major === 0)
+        return { kind: 'range', min, max: parts(major, minor + 1, 0) };
+    return { kind: 'range', min, max: parts(major + 1, 0, 0) };
+}
+/** True when `spec` resolves to a SET of versions (range or `latest`), not one. */
+export function isVersionRange(spec) {
+    const parsed = parseVersionSpec(spec);
+    return parsed !== null && parsed.kind !== 'exact';
+}
+/** Whether `version` satisfies `spec` (a string or an already-parsed spec). */
+export function satisfiesVersionSpec(version, spec) {
+    const parsed = typeof spec === 'string' ? parseVersionSpec(spec) : spec;
+    if (!parsed)
+        return typeof spec === 'string' && version === spec;
+    if (parsed.kind === 'exact')
+        return version === parsed.version;
+    const v = parseSemver(version);
+    if (!v)
+        return false;
+    if (parsed.kind === 'latest')
+        return v.prerelease.length === 0;
+    if (compareSemverParts(v, parsed.min) < 0 || compareSemverParts(v, parsed.max) >= 0)
+        return false;
+    if (v.prerelease.length === 0)
+        return true;
+    const { min } = parsed;
+    return min.prerelease.length > 0 && v.major === min.major && v.minor === min.minor && v.patch === min.patch;
+}
+/** The highest of `versions` satisfying `spec`, or `null`. */
+export function maxSatisfying(versions, spec) {
+    let best = null;
+    for (const v of versions) {
+        if (satisfiesVersionSpec(v, spec) && (best === null || compareSemver(v, best) > 0))
+            best = v;
+    }
+    return best;
+}
+// -- SQL ------------------------------------------------------------------------
+//
+// The `version` column is CHECK-constrained to `^\d+\.\d+\.\d+(-pre)?(\+build)?$`,
+// so the numeric parts are split out reliably: major/minor are the first two
+// dot fields, patch is the third with any `-pre` / `+build` suffix removed, and
+// the prerelease is whatever sits between the first `-` and any `+`.
+const majorOf = (col) => sql `split_part(${col}, '.', 1)::int`;
+const minorOf = (col) => sql `split_part(${col}, '.', 2)::int`;
+const patchOf = (col) => sql `substring(${col} from '^[0-9]+\\.[0-9]+\\.([0-9]+)')::int`;
+/** The prerelease suffix, or NULL for a stable version. */
+const prereleaseOf = (col) => sql `substring(split_part(${col}, '+', 1) from '^[0-9]+\\.[0-9]+\\.[0-9]+-(.+)$')`;
+const tupleOf = (col) => sql `(${majorOf(col)}, ${minorOf(col)}, ${patchOf(col)})`;
+const tupleLit = (p) => sql `(${p.major}::int, ${p.minor}::int, ${p.patch}::int)`;
+/**
+ * SQL predicate for `col` satisfying `spec`. Precision note: prerelease-vs-
+ * prerelease ordering WITHIN the lower bound's own tuple is not compared in SQL
+ * (every prerelease of that tuple is admitted) — {@link semverOrderBy} still
+ * ranks them, and the JS matcher is exact.
+ */
+export function versionSpecCondition(col, spec) {
+    const parsed = parseVersionSpec(spec);
+    if (!parsed)
+        return eq(col, spec);
+    if (parsed.kind === 'exact')
+        return eq(col, parsed.version);
+    const stable = sql `${prereleaseOf(col)} IS NULL`;
+    if (parsed.kind === 'latest')
+        return stable;
+    const { min, max } = parsed;
+    const inRange = and(sql `${tupleOf(col)} >= ${tupleLit(min)}`, sql `${tupleOf(col)} < ${tupleLit(max)}`);
+    if (min.prerelease.length === 0)
+        return and(inRange, stable);
+    // A prerelease lower bound: stable versions above it, plus prereleases of its own tuple.
+    return and(inRange, or(stable, sql `${tupleOf(col)} = ${tupleLit(min)}`));
+}
+/**
+ * ORDER BY terms ranking `col` highest-semver first: numeric major/minor/patch,
+ * a stable version above its prereleases, then the prerelease text (a
+ * lexicographic tiebreak — close to, not exactly, semver identifier order).
+ */
+export function semverOrderBy(col) {
+    return [
+        desc(majorOf(col)),
+        desc(minorOf(col)),
+        desc(patchOf(col)),
+        sql `${prereleaseOf(col)} IS NULL DESC`,
+        desc(prereleaseOf(col)),
+        asc(col),
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semver-range.js","sourceRoot":"","sources":["../../src/api/semver-range.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Version specs for plugin lookups (docs/plugin-installing.md).\n *\n * A small, dependency-free matcher for exactly the forms plugin references use:\n *\n *   exact    `1.2.3`, `1.2.3-rc.1`   that one version\n *   caret    `^1.2.3`                >=1.2.3 <2.0.0  (`^0.2.3` <0.3.0, `^0.0.3` <0.0.4)\n *            `^1`, `^1.2`            >=1.0.0 <2.0.0, >=1.2.0 <2.0.0  (`^0.2` <0.3.0, `^0` <1.0.0)\n *   tilde    `~1.2.3`                >=1.2.3 <1.3.0\n *            `~1`, `~1.2`            >=1.0.0 <2.0.0, >=1.2.0 <1.3.0\n *   partial  `1`, `1.x`, `1.2`, `1.2.x`  >=1.0.0 <2.0.0 / >=1.2.0 <1.3.0\n *   latest   `latest`                the highest stable version\n *\n * npm semantics throughout, including prereleases: a range never matches a\n * prerelease unless its own lower bound is a prerelease of the SAME\n * major.minor.patch (so `^1.2.3-beta.1` admits `1.2.3-beta.2` but not\n * `1.3.0-beta.1`). An exact spec may name a prerelease directly.\n *\n * The matcher runs in JS ({@link satisfiesVersionSpec}) and — for the query\n * builders — as SQL over the `version` column ({@link versionSpecCondition},\n * {@link semverOrderBy}); the two are kept equivalent by the shared tests.\n */\n\nimport { and, asc, desc, eq, or, sql, SQL } from 'drizzle-orm';\nimport type { AnyColumn } from 'drizzle-orm/column';\n\n/** A parsed `major.minor.patch[-prerelease][+build]` version. */\nexport interface SemverParts {\n  major: number;\n  minor: number;\n  patch: number;\n  /** Dot-separated prerelease identifiers; empty for a stable version. */\n  prerelease: string[];\n}\n\n/** A parsed version spec. `range` bounds are `[min, max)`. */\nexport type VersionSpec =\n  | { kind: 'exact'; version: string }\n  | { kind: 'latest' }\n  | { kind: 'range'; min: SemverParts; max: SemverParts };\n\nconst SEMVER = /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$/;\nconst PARTIAL = /^(0|[1-9]\\d*)(?:\\.(0|[1-9]\\d*|x|\\*))?(?:\\.(x|\\*))?$/;\n\n/** Upper bound on any numeric part (keeps SQL `::int` casts in range). */\nconst MAX_PART = 2_147_483_647;\n\n/** Parse a full semver string, or `null` when it isn't one. */\nexport function parseSemver(version: string): SemverParts | null {\n  const m = SEMVER.exec(version.trim());\n  if (!m) return null;\n  const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];\n  if (major > MAX_PART || minor > MAX_PART || patch > MAX_PART) return null;\n  return { major, minor, patch, prerelease: m[4] ? m[4].split('.') : [] };\n}\n\nfunction compareIdentifiers(a: string, b: string): number {\n  const an = /^\\d+$/.test(a);\n  const bn = /^\\d+$/.test(b);\n  if (an && bn) return Number(a) - Number(b);\n  if (an) return -1; // numeric identifiers sort below alphanumeric ones\n  if (bn) return 1;\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n\n/** Semver 2.0 precedence: negative when `a < b`, 0 when equal, positive when `a > b`. */\nexport function compareSemverParts(a: SemverParts, b: SemverParts): number {\n  if (a.major !== b.major) return a.major - b.major;\n  if (a.minor !== b.minor) return a.minor - b.minor;\n  if (a.patch !== b.patch) return a.patch - b.patch;\n  // A stable version outranks any prerelease of the same tuple.\n  if (!a.prerelease.length || !b.prerelease.length) return b.prerelease.length - a.prerelease.length;\n  for (let i = 0; i < Math.max(a.prerelease.length, b.prerelease.length); i++) {\n    if (a.prerelease[i] === undefined) return -1;\n    if (b.prerelease[i] === undefined) return 1;\n    const c = compareIdentifiers(a.prerelease[i]!, b.prerelease[i]!);\n    if (c !== 0) return c;\n  }\n  return 0;\n}\n\n/** {@link compareSemverParts} over strings; unparseable versions sort lowest. */\nexport function compareSemver(a: string, b: string): number {\n  const pa = parseSemver(a);\n  const pb = parseSemver(b);\n  if (!pa || !pb) return (pa ? 1 : 0) - (pb ? 1 : 0);\n  return compareSemverParts(pa, pb);\n}\n\nconst parts = (major: number, minor: number, patch: number, prerelease: string[] = []): SemverParts =>\n  ({ major, minor, patch, prerelease });\n\n/**\n * Parse a version spec, or `null` when it is none of the supported forms (the\n * caller then treats the input as a literal version, which matches nothing).\n */\nexport function parseVersionSpec(spec: string): VersionSpec | null {\n  const s = spec.trim();\n  if (s === 'latest') return { kind: 'latest' };\n\n  if (s.startsWith('^') || s.startsWith('~')) {\n    const partial = PARTIAL.exec(s.slice(1));\n    if (partial && !parseSemver(s.slice(1))) return partialOperatorRange(s[0] as '^' | '~', partial);\n    const base = parseSemver(s.slice(1));\n    if (!base) return null;\n    const { major, minor, patch } = base;\n    let max: SemverParts;\n    if (s[0] === '~') max = parts(major, minor + 1, 0);\n    else if (major > 0) max = parts(major + 1, 0, 0);\n    else if (minor > 0) max = parts(0, minor + 1, 0);\n    else max = parts(0, 0, patch + 1);\n    return { kind: 'range', min: base, max };\n  }\n\n  if (parseSemver(s)) return { kind: 'exact', version: s };\n\n  const m = PARTIAL.exec(s);\n  if (!m) return null;\n  const major = Number(m[1]);\n  const minorWild = m[2] === undefined || m[2] === 'x' || m[2] === '*';\n  if (major > MAX_PART) return null;\n  if (minorWild) return { kind: 'range', min: parts(major, 0, 0), max: parts(major + 1, 0, 0) };\n  const minor = Number(m[2]);\n  if (minor > MAX_PART) return null;\n  return { kind: 'range', min: parts(major, minor, 0), max: parts(major, minor + 1, 0) };\n}\n\n/**\n * `^` / `~` over a PARTIAL version (npm): the missing parts are zero, and the\n * upper bound follows the operator — `^1` / `~1` <2.0.0, `^1.2` <2.0.0 but\n * `~1.2` <1.3.0, and a zero major narrows a caret to the next minor\n * (`^0.2` <0.3.0) or major (`^0` <1.0.0).\n */\nfunction partialOperatorRange(op: '^' | '~', m: RegExpExecArray): VersionSpec | null {\n  const major = Number(m[1]);\n  const minorGiven = m[2] !== undefined && m[2] !== 'x' && m[2] !== '*';\n  const minor = minorGiven ? Number(m[2]) : 0;\n  if (major > MAX_PART || minor > MAX_PART) return null;\n  const min = parts(major, minor, 0);\n  if (!minorGiven) return { kind: 'range', min, max: parts(major + 1, 0, 0) };\n  if (op === '~' || major === 0) return { kind: 'range', min, max: parts(major, minor + 1, 0) };\n  return { kind: 'range', min, max: parts(major + 1, 0, 0) };\n}\n\n/** True when `spec` resolves to a SET of versions (range or `latest`), not one. */\nexport function isVersionRange(spec: string): boolean {\n  const parsed = parseVersionSpec(spec);\n  return parsed !== null && parsed.kind !== 'exact';\n}\n\n/** Whether `version` satisfies `spec` (a string or an already-parsed spec). */\nexport function satisfiesVersionSpec(version: string, spec: string | VersionSpec): boolean {\n  const parsed = typeof spec === 'string' ? parseVersionSpec(spec) : spec;\n  if (!parsed) return typeof spec === 'string' && version === spec;\n  if (parsed.kind === 'exact') return version === parsed.version;\n  const v = parseSemver(version);\n  if (!v) return false;\n  if (parsed.kind === 'latest') return v.prerelease.length === 0;\n  if (compareSemverParts(v, parsed.min) < 0 || compareSemverParts(v, parsed.max) >= 0) return false;\n  if (v.prerelease.length === 0) return true;\n  const { min } = parsed;\n  return min.prerelease.length > 0 && v.major === min.major && v.minor === min.minor && v.patch === min.patch;\n}\n\n/** The highest of `versions` satisfying `spec`, or `null`. */\nexport function maxSatisfying(versions: readonly string[], spec: string | VersionSpec): string | null {\n  let best: string | null = null;\n  for (const v of versions) {\n    if (satisfiesVersionSpec(v, spec) && (best === null || compareSemver(v, best) > 0)) best = v;\n  }\n  return best;\n}\n\n// -- SQL ------------------------------------------------------------------------\n//\n// The `version` column is CHECK-constrained to `^\\d+\\.\\d+\\.\\d+(-pre)?(\\+build)?$`,\n// so the numeric parts are split out reliably: major/minor are the first two\n// dot fields, patch is the third with any `-pre` / `+build` suffix removed, and\n// the prerelease is whatever sits between the first `-` and any `+`.\n\nconst majorOf = (col: AnyColumn): SQL => sql`split_part(${col}, '.', 1)::int`;\nconst minorOf = (col: AnyColumn): SQL => sql`split_part(${col}, '.', 2)::int`;\nconst patchOf = (col: AnyColumn): SQL => sql`substring(${col} from '^[0-9]+\\\\.[0-9]+\\\\.([0-9]+)')::int`;\n/** The prerelease suffix, or NULL for a stable version. */\nconst prereleaseOf = (col: AnyColumn): SQL => sql`substring(split_part(${col}, '+', 1) from '^[0-9]+\\\\.[0-9]+\\\\.[0-9]+-(.+)$')`;\n\nconst tupleOf = (col: AnyColumn): SQL => sql`(${majorOf(col)}, ${minorOf(col)}, ${patchOf(col)})`;\nconst tupleLit = (p: SemverParts): SQL => sql`(${p.major}::int, ${p.minor}::int, ${p.patch}::int)`;\n\n/**\n * SQL predicate for `col` satisfying `spec`. Precision note: prerelease-vs-\n * prerelease ordering WITHIN the lower bound's own tuple is not compared in SQL\n * (every prerelease of that tuple is admitted) — {@link semverOrderBy} still\n * ranks them, and the JS matcher is exact.\n */\nexport function versionSpecCondition(col: AnyColumn, spec: string): SQL {\n  const parsed = parseVersionSpec(spec);\n  if (!parsed) return eq(col, spec);\n  if (parsed.kind === 'exact') return eq(col, parsed.version);\n  const stable = sql`${prereleaseOf(col)} IS NULL`;\n  if (parsed.kind === 'latest') return stable;\n\n  const { min, max } = parsed;\n  const inRange = and(sql`${tupleOf(col)} >= ${tupleLit(min)}`, sql`${tupleOf(col)} < ${tupleLit(max)}`)!;\n  if (min.prerelease.length === 0) return and(inRange, stable)!;\n  // A prerelease lower bound: stable versions above it, plus prereleases of its own tuple.\n  return and(inRange, or(stable, sql`${tupleOf(col)} = ${tupleLit(min)}`))!;\n}\n\n/**\n * ORDER BY terms ranking `col` highest-semver first: numeric major/minor/patch,\n * a stable version above its prereleases, then the prerelease text (a\n * lexicographic tiebreak — close to, not exactly, semver identifier order).\n */\nexport function semverOrderBy(col: AnyColumn): SQL[] {\n  return [\n    desc(majorOf(col)),\n    desc(minorOf(col)),\n    desc(patchOf(col)),\n    sql`${prereleaseOf(col)} IS NULL DESC`,\n    desc(prereleaseOf(col)),\n    asc(col),\n  ];\n}\n"]}

package/lib/api/soft-delete-sweep.js

@@ -17,13 +17,13 @@
  * than left to the caller. This is a cross-tenant housekeeping job, not a
  * per-org operation.
  */
-import { createLogger, createScheduler, createEnvRedisLock, closeLeaderLock } from '@pipeline-builder/api-core';
+import { createLogger, createScheduler, envBool, envInt } from '@pipeline-builder/api-core';
 import { runWithTenantContext } from '../database/tenancy.js';
 const logger = createLogger('soft-delete-sweep');
 /** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging
  *  (tombstones still accumulate + stay restorable; nothing is destroyed). */
 export function isSoftDeletePurgeEnabled() {
-    return (process.env.SOFT_DELETE_PURGE_ENABLED ?? 'true').toLowerCase() !== 'false';
+    return envBool('SOFT_DELETE_PURGE_ENABLED', true);
 }
 /**
  * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in
@@ -93,32 +93,20 @@ export function createSoftDeletePurgeScheduler(opts) {
         logger.info('Soft-delete purge scheduler disabled (SOFT_DELETE_PURGE_ENABLED=false)', { service: opts.service });
         return null;
     }
-    const intervalMs = Math.max(1, Number.parseInt(process.env.SOFT_DELETE_PURGE_INTERVAL_HOURS ?? '6', 10) || 6) * 60 * 60 * 1000;
-    const startupDelayMs = Math.max(0, Number.parseInt(process.env.SOFT_DELETE_PURGE_STARTUP_DELAY_MS ?? '120000', 10) || 0);
-    const lockTtlMs = Math.max(1000, Number.parseInt(process.env.SOFT_DELETE_PURGE_LOCK_TTL_MS ?? '900000', 10) || 900000);
-    const lock = createEnvRedisLock();
+    const intervalMs = envInt('SOFT_DELETE_PURGE_INTERVAL_HOURS', 6, { min: 1 }) * 60 * 60 * 1000;
+    const startupDelayMs = envInt('SOFT_DELETE_PURGE_STARTUP_DELAY_MS', 120_000, { min: 0 });
+    const lockTtlMs = envInt('SOFT_DELETE_PURGE_LOCK_TTL_MS', 900_000, { min: 1000 });
     logger.info('Soft-delete purge scheduler starting', {
         service: opts.service,
         entities: opts.entities.map((e) => e.name),
         intervalHours: intervalMs / 3_600_000,
-        locked: !!lock,
     });
-    const scheduler = createScheduler({
+    return createScheduler({
         name: `soft-delete-purge:${opts.service}`,
         intervalMs,
         startupDelayMs,
         run: async () => { await runSoftDeletePurge(opts.entities, opts); },
-        ...(lock ? { lock: { redis: () => lock, key: `soft-delete-purge:${opts.service}:leader`, ttlMs: lockTtlMs } } : {}),
+        lock: { key: `soft-delete-purge:${opts.service}:leader`, ttlMs: lockTtlMs },
     });
-    if (!lock)
-        return scheduler;
-    // Own the leader-lock Redis client's lifecycle: `stop()` (wired to the
-    // service's runServer onShutdown) also closes the connection so it can't keep
-    // the process from exiting cleanly. Per-cycle lock acquire/release is handled
-    // by withLeaderLock; this is just connection teardown.
-    return {
-        start: () => scheduler.start(),
-        stop: () => { scheduler.stop(); void closeLeaderLock(lock); },
-    };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"soft-delete-sweep.js","sourceRoot":"","sources":["../../src/api/soft-delete-sweep.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared soft-delete retention purge.\n *\n * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a\n * `purge_after` deadline). This orchestrator runs one purge pass across a set\n * of such entities, hard-deleting tombstones whose deadline has passed. It is\n * the `run` callback a service hands to `createScheduler` (leader-locked), so\n * only one pod sweeps at a time.\n *\n * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({\n * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and\n * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant\n * context would see zero rows on those tables — and in production (`strict`\n * mode) `withTenantTx` throws outright — so the scope is established here rather\n * than left to the caller. This is a cross-tenant housekeeping job, not a\n * per-org operation.\n */\n\nimport { createLogger, createScheduler, createEnvRedisLock, closeLeaderLock, type Scheduler } from '@pipeline-builder/api-core';\nimport { runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('soft-delete-sweep');\n\n/** The slice of a CrudService the sweep needs, plus a label for logs/metrics. */\nexport interface PurgeableEntity {\n  /** Table/entity label (e.g. 'pipeline') for per-table logging. */\n  name: string;\n  /** Hard-delete up to `limit` expired tombstones; returns rows purged. */\n  purgeExpired(now: Date, limit?: number): Promise<number>;\n}\n\nexport interface SoftDeletePurgeOptions {\n  /** Rows per batch per table (default 500). */\n  batchSize?: number;\n  /** Max batches per table per tick (default 20 → ≤ 10k/table/tick); the rest\n   *  is deferred to the next tick so a huge backlog can't blow the lock TTL. */\n  maxBatchesPerEntity?: number;\n}\n\n/** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging\n *  (tombstones still accumulate + stay restorable; nothing is destroyed). */\nexport function isSoftDeletePurgeEnabled(): boolean {\n  return (process.env.SOFT_DELETE_PURGE_ENABLED ?? 'true').toLowerCase() !== 'false';\n}\n\n/**\n * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in\n * batches until a batch returns `< batchSize` (drained) or the per-tick cap is\n * hit (logged; continued next tick). Never throws — a failing entity is logged\n * and the sweep moves on. Returns per-entity purged counts (also logged).\n */\nexport async function runSoftDeletePurge(\n  entities: PurgeableEntity[],\n  opts: SoftDeletePurgeOptions = {},\n): Promise<Record<string, number>> {\n  const counts: Record<string, number> = {};\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');\n    return counts;\n  }\n\n  const batchSize = opts.batchSize ?? 500;\n  const maxBatches = opts.maxBatchesPerEntity ?? 20;\n  // One `now` for the whole tick — rows that expire mid-sweep wait for the next.\n  const now = new Date();\n\n  // Establish a sysadmin scope so every `purgeExpired` (which routes through\n  // `withTenantTx`) bypasses RLS and spans all orgs. Without this, FORCE'd\n  // tables return zero rows and production `strict` mode throws.\n  return runWithTenantContext({ isSuperAdmin: true }, async () => {\n    for (const entity of entities) {\n      let total = 0;\n      for (let i = 0; i < maxBatches; i++) {\n        let purged: number;\n        try {\n          purged = await entity.purgeExpired(now, batchSize);\n        } catch (err) {\n          logger.error('Purge batch failed', { entity: entity.name, error: String(err) });\n          break;\n        }\n        total += purged;\n        if (purged < batchSize) break; // drained\n        if (i === maxBatches - 1) {\n          logger.warn('Purge hit per-tick cap; remaining tombstones deferred to next tick', {\n            entity: entity.name, purgedThisTick: total,\n          });\n        }\n      }\n      if (total > 0) logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });\n      counts[entity.name] = total;\n    }\n\n    return counts;\n  });\n}\n\n// -- Scheduler factory --------------------------------------------------------\n\nexport interface SoftDeletePurgeSchedulerOptions extends SoftDeletePurgeOptions {\n  /** Service label for logs + the leader-lock key (e.g. 'pipeline', 'plugin'). */\n  service: string;\n  /** Entities to sweep — usually the service's own CrudService singletons. */\n  entities: PurgeableEntity[];\n}\n\n/**\n * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete\n * purge sweep for `entities` on a cadence. The caller `.start()`s it and wires\n * `stop()` to SIGTERM. Returns null when purging is disabled.\n *\n * Env config:\n *   SOFT_DELETE_PURGE_ENABLED           (default true; false ⇒ null, no sweep)\n *   SOFT_DELETE_PURGE_INTERVAL_HOURS    (default 6)\n *   SOFT_DELETE_PURGE_STARTUP_DELAY_MS  (default 120000 — 2 min settle)\n *   SOFT_DELETE_PURGE_LOCK_TTL_MS       (default 900000 — 15 min; outlasts a\n *                                        sweep, stays under the interval)\n *\n * A cross-pod leader lock (when Redis is configured) means only one replica\n * sweeps per window; without Redis it runs on every pod — still safe, since the\n * purge is a batched idempotent DELETE, just redundant.\n */\nexport function createSoftDeletePurgeScheduler(opts: SoftDeletePurgeSchedulerOptions): Scheduler | null {\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.info('Soft-delete purge scheduler disabled (SOFT_DELETE_PURGE_ENABLED=false)', { service: opts.service });\n    return null;\n  }\n\n  const intervalMs = Math.max(1, Number.parseInt(process.env.SOFT_DELETE_PURGE_INTERVAL_HOURS ?? '6', 10) || 6) * 60 * 60 * 1000;\n  const startupDelayMs = Math.max(0, Number.parseInt(process.env.SOFT_DELETE_PURGE_STARTUP_DELAY_MS ?? '120000', 10) || 0);\n  const lockTtlMs = Math.max(1000, Number.parseInt(process.env.SOFT_DELETE_PURGE_LOCK_TTL_MS ?? '900000', 10) || 900000);\n  const lock = createEnvRedisLock();\n\n  logger.info('Soft-delete purge scheduler starting', {\n    service: opts.service,\n    entities: opts.entities.map((e) => e.name),\n    intervalHours: intervalMs / 3_600_000,\n    locked: !!lock,\n  });\n\n  const scheduler = createScheduler({\n    name: `soft-delete-purge:${opts.service}`,\n    intervalMs,\n    startupDelayMs,\n    run: async () => { await runSoftDeletePurge(opts.entities, opts); },\n    ...(lock ? { lock: { redis: () => lock, key: `soft-delete-purge:${opts.service}:leader`, ttlMs: lockTtlMs } } : {}),\n  });\n  if (!lock) return scheduler;\n\n  // Own the leader-lock Redis client's lifecycle: `stop()` (wired to the\n  // service's runServer onShutdown) also closes the connection so it can't keep\n  // the process from exiting cleanly. Per-cycle lock acquire/release is handled\n  // by withLeaderLock; this is just connection teardown.\n  return {\n    start: () => scheduler.start(),\n    stop: () => { scheduler.stop(); void closeLeaderLock(lock); },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"soft-delete-sweep.js","sourceRoot":"","sources":["../../src/api/soft-delete-sweep.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared soft-delete retention purge.\n *\n * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a\n * `purge_after` deadline). This orchestrator runs one purge pass across a set\n * of such entities, hard-deleting tombstones whose deadline has passed. It is\n * the `run` callback a service hands to `createScheduler` (leader-locked), so\n * only one pod sweeps at a time.\n *\n * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({\n * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and\n * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant\n * context would see zero rows on those tables — and in production (`strict`\n * mode) `withTenantTx` throws outright — so the scope is established here rather\n * than left to the caller. This is a cross-tenant housekeeping job, not a\n * per-org operation.\n */\n\nimport { createLogger, createScheduler, envBool, envInt, type Scheduler } from '@pipeline-builder/api-core';\nimport { runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('soft-delete-sweep');\n\n/** The slice of a CrudService the sweep needs, plus a label for logs/metrics. */\nexport interface PurgeableEntity {\n  /** Table/entity label (e.g. 'pipeline') for per-table logging. */\n  name: string;\n  /** Hard-delete up to `limit` expired tombstones; returns rows purged. */\n  purgeExpired(now: Date, limit?: number): Promise<number>;\n}\n\nexport interface SoftDeletePurgeOptions {\n  /** Rows per batch per table (default 500). */\n  batchSize?: number;\n  /** Max batches per table per tick (default 20 → ≤ 10k/table/tick); the rest\n   *  is deferred to the next tick so a huge backlog can't blow the lock TTL. */\n  maxBatchesPerEntity?: number;\n}\n\n/** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging\n *  (tombstones still accumulate + stay restorable; nothing is destroyed). */\nexport function isSoftDeletePurgeEnabled(): boolean {\n  return envBool('SOFT_DELETE_PURGE_ENABLED', true);\n}\n\n/**\n * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in\n * batches until a batch returns `< batchSize` (drained) or the per-tick cap is\n * hit (logged; continued next tick). Never throws — a failing entity is logged\n * and the sweep moves on. Returns per-entity purged counts (also logged).\n */\nexport async function runSoftDeletePurge(\n  entities: PurgeableEntity[],\n  opts: SoftDeletePurgeOptions = {},\n): Promise<Record<string, number>> {\n  const counts: Record<string, number> = {};\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');\n    return counts;\n  }\n\n  const batchSize = opts.batchSize ?? 500;\n  const maxBatches = opts.maxBatchesPerEntity ?? 20;\n  // One `now` for the whole tick — rows that expire mid-sweep wait for the next.\n  const now = new Date();\n\n  // Establish a sysadmin scope so every `purgeExpired` (which routes through\n  // `withTenantTx`) bypasses RLS and spans all orgs. Without this, FORCE'd\n  // tables return zero rows and production `strict` mode throws.\n  return runWithTenantContext({ isSuperAdmin: true }, async () => {\n    for (const entity of entities) {\n      let total = 0;\n      for (let i = 0; i < maxBatches; i++) {\n        let purged: number;\n        try {\n          purged = await entity.purgeExpired(now, batchSize);\n        } catch (err) {\n          logger.error('Purge batch failed', { entity: entity.name, error: String(err) });\n          break;\n        }\n        total += purged;\n        if (purged < batchSize) break; // drained\n        if (i === maxBatches - 1) {\n          logger.warn('Purge hit per-tick cap; remaining tombstones deferred to next tick', {\n            entity: entity.name, purgedThisTick: total,\n          });\n        }\n      }\n      if (total > 0) logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });\n      counts[entity.name] = total;\n    }\n\n    return counts;\n  });\n}\n\n// -- Scheduler factory --------------------------------------------------------\n\nexport interface SoftDeletePurgeSchedulerOptions extends SoftDeletePurgeOptions {\n  /** Service label for logs + the leader-lock key (e.g. 'pipeline', 'plugin'). */\n  service: string;\n  /** Entities to sweep — usually the service's own CrudService singletons. */\n  entities: PurgeableEntity[];\n}\n\n/**\n * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete\n * purge sweep for `entities` on a cadence. The caller `.start()`s it and wires\n * `stop()` to SIGTERM. Returns null when purging is disabled.\n *\n * Env config:\n *   SOFT_DELETE_PURGE_ENABLED           (default true; false ⇒ null, no sweep)\n *   SOFT_DELETE_PURGE_INTERVAL_HOURS    (default 6)\n *   SOFT_DELETE_PURGE_STARTUP_DELAY_MS  (default 120000 — 2 min settle)\n *   SOFT_DELETE_PURGE_LOCK_TTL_MS       (default 900000 — 15 min; outlasts a\n *                                        sweep, stays under the interval)\n *\n * A cross-pod leader lock (when Redis is configured) means only one replica\n * sweeps per window; without Redis it runs on every pod — still safe, since the\n * purge is a batched idempotent DELETE, just redundant.\n */\nexport function createSoftDeletePurgeScheduler(opts: SoftDeletePurgeSchedulerOptions): Scheduler | null {\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.info('Soft-delete purge scheduler disabled (SOFT_DELETE_PURGE_ENABLED=false)', { service: opts.service });\n    return null;\n  }\n\n  const intervalMs = envInt('SOFT_DELETE_PURGE_INTERVAL_HOURS', 6, { min: 1 }) * 60 * 60 * 1000;\n  const startupDelayMs = envInt('SOFT_DELETE_PURGE_STARTUP_DELAY_MS', 120_000, { min: 0 });\n  const lockTtlMs = envInt('SOFT_DELETE_PURGE_LOCK_TTL_MS', 900_000, { min: 1000 });\n\n  logger.info('Soft-delete purge scheduler starting', {\n    service: opts.service,\n    entities: opts.entities.map((e) => e.name),\n    intervalHours: intervalMs / 3_600_000,\n  });\n\n  return createScheduler({\n    name: `soft-delete-purge:${opts.service}`,\n    intervalMs,\n    startupDelayMs,\n    run: async () => { await runSoftDeletePurge(opts.entities, opts); },\n    lock: { key: `soft-delete-purge:${opts.service}:leader`, ttlMs: lockTtlMs },\n  });\n}\n"]}

package/lib/core/query-filters.d.ts

@@ -96,11 +96,26 @@ export interface PluginFilter extends CommonFilter {
      */
     readonly name?: string;
     /**
-     * Plugin version to filter by
-     * Supports semantic versioning
-     * @example "1.0.0", "^2.0.0", "~1.2.3"
+     * How `name` matches: `contains` (default — case-insensitive substring, for
+     * list/search) or `exact` (resolution — the lookup path). Internal: not in
+     * the public filter schema.
+     */
+    readonly nameMatch?: 'exact' | 'contains';
+    /**
+     * Publisher handle of an installed listing to resolve through.
+     * Lookup only: a `plugins` row query ignores it (the resolver routes a
+     * qualified reference to the listing, never to an org's own rows).
+     */
+    readonly publisher?: string;
+    /**
+     * Plugin version spec: exact (`1.2.3`), caret (`^1.2.3`), tilde (`~1.2.3`),
+     * partial (`1`, `1.2`, `1.x`) or `latest` — see semver-range.ts. A range never
+     * matches a yanked version.
+     * @example "1.0.0", "^2.0.0", "~1.2.3", "latest"
      */
     readonly version?: string;
+    /** Exclude yanked versions (resolution without a version spec). Internal. */
+    readonly excludeYanked?: boolean;
     /**
      * Keyword to search within the keywords JSONB array (case-insensitive contains)
      */

package/lib/core/query-filters.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-filters.js","sourceRoot":"","sources":["../../src/core/query-filters.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Visibility } from '@pipeline-builder/api-core';\n\n/**\n * Base filter interface containing common filter properties shared across all entity types.\n *\n * @example\n * ```typescript\n * const filter: CommonFilter = {\n *   id: '123',\n *   orgId: 'my-org',\n *   visibility: 'public',\n *   isDefault: true,\n *   isActive: true\n * };\n * ```\n */\nexport interface CommonFilter {\n  /**\n   * Unique identifier for the entity\n   * Can be a single ID or array of IDs for batch filtering\n   */\n  readonly id?: string | string[];\n\n  // --- Viewer context (server-set, NEVER client-supplied) ---------------------\n  // Only entities whose visibility predicate has a PER-USER rung read these —\n  // pipeline templates (`private` is author-only) and messages (a per-user\n  // targeted row is visible only to its target). Their services stamp them from\n  // the request's `TenantContext` via `withViewerContext`, so no route or query\n  // string can inject them. Everything else ignores them.\n  //\n  // Both fail CLOSED when absent: no viewer means the per-user rung matches\n  // NOTHING, never everything.\n\n  /** Caller's user id, matched against the entity's per-user column. */\n  readonly viewerUserId?: string;\n  /** Whether the caller is a platform super-admin (sees every rung). */\n  readonly viewerIsSuperAdmin?: boolean;\n\n  /**\n   * Organization identifier to filter entities by organization\n   * Can be a single org ID or array for multi-org filtering\n   */\n  readonly orgId?: string | string[];\n\n  /**\n   * Narrow to one rung of the shared three-rung sharing ladder. Applied WITHIN\n   * what the caller can already see — never widens it.\n   * @see Visibility\n   */\n  readonly visibility?: Visibility | string;\n\n  /**\n   * Filter by default status\n   * - true: Only default entities\n   * - false: Only non-default entities\n   * - undefined: All entities\n   */\n  readonly isDefault?: boolean;\n\n  /**\n   * Filter by active/inactive status\n   * - true: Only active entities\n   * - false: Only inactive entities\n   * - undefined: All entities\n   */\n  readonly isActive?: boolean;\n\n  /**\n   * Number of results to return\n   * @minimum 1\n   * @maximum 1000\n   */\n  readonly limit?: number;\n\n  /**\n   * Number of results to skip (for pagination)\n   * @minimum 0\n   */\n  readonly offset?: number;\n\n  /**\n   * Sort field and direction\n   * @example \"name:asc\", \"createdAt:desc\"\n   */\n  readonly sort?: string;\n\n  /**\n   * Filter by catalog owner (developer-portal \"my services\" view).\n   * Matches the entity's `ownerId` exactly (a user id or team id).\n   * Only applied by builders for entities that carry an owner column\n   * (pipelines, plugins); ignored elsewhere.\n   */\n  readonly ownerId?: string;\n\n  /**\n   * Filter by lifecycle stage (experimental | production | deprecated).\n   * Only applied by builders for entities that carry a lifecycle column.\n   */\n  readonly lifecycle?: string;\n}\n\n/**\n * Filter interface for plugin-specific properties.\n * Extends CommonFilter to include plugin-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PluginFilter = {\n *   name: 'nodejs-build',\n *   version: '1.0.0',\n *   isActive: true\n * };\n * ```\n */\nexport interface PluginFilter extends CommonFilter {\n  /**\n   * Plugin name to filter by\n   */\n  readonly name?: string;\n\n  /**\n   * Plugin version to filter by\n   * Supports semantic versioning\n   * @example \"1.0.0\", \"^2.0.0\", \"~1.2.3\"\n   */\n  readonly version?: string;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n\n  /**\n   * Plugin category to filter by\n   * @example \"language\", \"security\", \"testing\"\n   */\n  readonly category?: string;\n}\n\n/**\n * Filter interface for pipeline-specific properties.\n * Extends CommonFilter to include pipeline-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PipelineFilter = {\n *   project: 'my-app',\n *   organization: 'my-org',\n *   pipelineName: 'my-pipeline',\n *   isActive: true\n * };\n * ```\n */\nexport interface PipelineFilter extends CommonFilter {\n  /**\n   * Project name associated with the pipeline\n   */\n  readonly project?: string;\n\n  /**\n   * Organization name associated with the pipeline\n   */\n  readonly organization?: string;\n\n  /**\n   * Pipeline name to filter by\n   */\n  readonly pipelineName?: string;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n}\n\n/** Filter interface for pipeline-template queries (golden-path catalog). */\nexport interface PipelineTemplateFilter extends CommonFilter {\n  /** Template name (case-insensitive contains). */\n  readonly name?: string;\n  /** Category to filter by (e.g. 'language', 'general'). */\n  readonly category?: string;\n  /** Keyword search within the keywords JSONB array. */\n  readonly keyword?: string;\n  // Sharing rung + viewer context are inherited from CommonFilter.\n}\n\n/**\n * Filter interface for message-specific properties.\n * Extends CommonFilter to include message-related filter options.\n */\nexport interface MessageFilter extends CommonFilter {\n  /**\n   * Thread ID to filter by (for fetching thread replies).\n   * Pass `null` to filter for root messages only (threadId IS NULL).\n   */\n  readonly threadId?: string | null;\n\n  /**\n   * Recipient organization ID to filter by\n   * Use '*' for broadcast announcements\n   */\n  readonly recipientOrgId?: string;\n\n  /**\n   * Recipient user ID to filter by (per-user targeting within the recipient\n   * org). Pass `null` to match org-wide messages only (recipient_user_id IS\n   * NULL). Rarely set directly by callers — see `viewerUserId` for the\n   * visibility-scoping variant.\n   */\n  readonly recipientUserId?: string | null;\n\n  // NOTE: the VIEWER's user id (`viewerUserId`) is inherited from CommonFilter.\n  // For messages it is NOT a column filter: when present, the recipient-side\n  // branch in `buildMessageConditions` widens to include rows targeted at this\n  // user (recipient_user_id = viewerUserId) ALONGSIDE org-wide ones\n  // (recipient_user_id IS NULL). When absent, only org-wide recipient rows are\n  // visible, so a user-targeted message stays private to its target, the sender,\n  // and the system org. MessageService stamps it from the tenant context.\n\n  /**\n   * Message type filter\n   */\n  readonly messageType?: 'announcement' | 'conversation';\n\n  /**\n   * Filter by priority level\n   */\n  readonly priority?: 'normal' | 'high' | 'urgent';\n\n  /**\n   * Channel/inbox-bucket filter (e.g. 'support', 'help'). Matches rows\n   * exactly; pass null to match channel IS NULL (org-to-org messages).\n   */\n  readonly channel?: string | null;\n\n  /**\n   * Filter by read state for the requesting org.\n   * Implemented as a JSONB key-existence check against `messages.read_by`\n   * (a `{ [orgId]: isoTimestamp }` map), using the orgId passed to\n   * `buildMessageConditions`.\n   * - true  → only messages the org has read (orgId key exists in read_by)\n   * - false → only messages the org has NOT read\n   * - undefined → no read-state filter\n   */\n  readonly isRead?: boolean;\n\n  /**\n   * Free-text inbox search. Case-insensitive substring match against the\n   * message `subject` OR `content` (LIKE wildcards in the term are escaped, so a\n   * literal `%`/`_` matches itself). Applied on top of the visibility scope, so\n   * it never widens what the caller can see.\n   */\n  readonly search?: string;\n}\n\n// ========================================\n// Compliance Filters\n// ========================================\n\n/**\n * Filter for compliance policies.\n */\nexport interface CompliancePolicyFilter extends CommonFilter {\n  readonly name?: string;\n  readonly isTemplate?: boolean;\n}\n\n/**\n * Filter for compliance rules.\n */\nexport interface ComplianceRuleFilter extends CommonFilter {\n  readonly name?: string;\n  readonly policyId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly field?: string;\n  readonly severity?: 'warning' | 'error' | 'critical';\n  readonly scope?: 'org' | 'published';\n  readonly tag?: string;\n}\n\n/**\n * Filter for compliance exemptions.\n */\nexport interface ComplianceExemptionFilter {\n  readonly orgId?: string;\n  readonly ruleId?: string;\n  readonly entityType?: 'plugin' | 'pipeline';\n  readonly entityId?: string;\n  readonly status?: 'pending' | 'approved' | 'rejected' | 'expired';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance audit log entries.\n */\nexport interface ComplianceAuditFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly action?: string;\n  readonly result?: 'pass' | 'warn' | 'block';\n  readonly scanId?: string;\n  readonly dateFrom?: string;\n  readonly dateTo?: string;\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance scans.\n */\nexport interface ComplianceScanFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline' | 'all';\n  readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';\n  readonly triggeredBy?: 'manual' | 'scheduled' | 'rule-change' | 'rule-dry-run';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-filters.js","sourceRoot":"","sources":["../../src/core/query-filters.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Visibility } from '@pipeline-builder/api-core';\n\n/**\n * Base filter interface containing common filter properties shared across all entity types.\n *\n * @example\n * ```typescript\n * const filter: CommonFilter = {\n *   id: '123',\n *   orgId: 'my-org',\n *   visibility: 'public',\n *   isDefault: true,\n *   isActive: true\n * };\n * ```\n */\nexport interface CommonFilter {\n  /**\n   * Unique identifier for the entity\n   * Can be a single ID or array of IDs for batch filtering\n   */\n  readonly id?: string | string[];\n\n  // --- Viewer context (server-set, NEVER client-supplied) ---------------------\n  // Only entities whose visibility predicate has a PER-USER rung read these —\n  // pipeline templates (`private` is author-only) and messages (a per-user\n  // targeted row is visible only to its target). Their services stamp them from\n  // the request's `TenantContext` via `withViewerContext`, so no route or query\n  // string can inject them. Everything else ignores them.\n  //\n  // Both fail CLOSED when absent: no viewer means the per-user rung matches\n  // NOTHING, never everything.\n\n  /** Caller's user id, matched against the entity's per-user column. */\n  readonly viewerUserId?: string;\n  /** Whether the caller is a platform super-admin (sees every rung). */\n  readonly viewerIsSuperAdmin?: boolean;\n\n  /**\n   * Organization identifier to filter entities by organization\n   * Can be a single org ID or array for multi-org filtering\n   */\n  readonly orgId?: string | string[];\n\n  /**\n   * Narrow to one rung of the shared three-rung sharing ladder. Applied WITHIN\n   * what the caller can already see — never widens it.\n   * @see Visibility\n   */\n  readonly visibility?: Visibility | string;\n\n  /**\n   * Filter by default status\n   * - true: Only default entities\n   * - false: Only non-default entities\n   * - undefined: All entities\n   */\n  readonly isDefault?: boolean;\n\n  /**\n   * Filter by active/inactive status\n   * - true: Only active entities\n   * - false: Only inactive entities\n   * - undefined: All entities\n   */\n  readonly isActive?: boolean;\n\n  /**\n   * Number of results to return\n   * @minimum 1\n   * @maximum 1000\n   */\n  readonly limit?: number;\n\n  /**\n   * Number of results to skip (for pagination)\n   * @minimum 0\n   */\n  readonly offset?: number;\n\n  /**\n   * Sort field and direction\n   * @example \"name:asc\", \"createdAt:desc\"\n   */\n  readonly sort?: string;\n\n  /**\n   * Filter by catalog owner (developer-portal \"my services\" view).\n   * Matches the entity's `ownerId` exactly (a user id or team id).\n   * Only applied by builders for entities that carry an owner column\n   * (pipelines, plugins); ignored elsewhere.\n   */\n  readonly ownerId?: string;\n\n  /**\n   * Filter by lifecycle stage (experimental | production | deprecated).\n   * Only applied by builders for entities that carry a lifecycle column.\n   */\n  readonly lifecycle?: string;\n}\n\n/**\n * Filter interface for plugin-specific properties.\n * Extends CommonFilter to include plugin-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PluginFilter = {\n *   name: 'nodejs-build',\n *   version: '1.0.0',\n *   isActive: true\n * };\n * ```\n */\nexport interface PluginFilter extends CommonFilter {\n  /**\n   * Plugin name to filter by\n   */\n  readonly name?: string;\n\n  /**\n   * How `name` matches: `contains` (default — case-insensitive substring, for\n   * list/search) or `exact` (resolution — the lookup path). Internal: not in\n   * the public filter schema.\n   */\n  readonly nameMatch?: 'exact' | 'contains';\n\n  /**\n   * Publisher handle of an installed listing to resolve through.\n   * Lookup only: a `plugins` row query ignores it (the resolver routes a\n   * qualified reference to the listing, never to an org's own rows).\n   */\n  readonly publisher?: string;\n\n  /**\n   * Plugin version spec: exact (`1.2.3`), caret (`^1.2.3`), tilde (`~1.2.3`),\n   * partial (`1`, `1.2`, `1.x`) or `latest` — see semver-range.ts. A range never\n   * matches a yanked version.\n   * @example \"1.0.0\", \"^2.0.0\", \"~1.2.3\", \"latest\"\n   */\n  readonly version?: string;\n\n  /** Exclude yanked versions (resolution without a version spec). Internal. */\n  readonly excludeYanked?: boolean;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n\n  /**\n   * Plugin category to filter by\n   * @example \"language\", \"security\", \"testing\"\n   */\n  readonly category?: string;\n}\n\n/**\n * Filter interface for pipeline-specific properties.\n * Extends CommonFilter to include pipeline-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PipelineFilter = {\n *   project: 'my-app',\n *   organization: 'my-org',\n *   pipelineName: 'my-pipeline',\n *   isActive: true\n * };\n * ```\n */\nexport interface PipelineFilter extends CommonFilter {\n  /**\n   * Project name associated with the pipeline\n   */\n  readonly project?: string;\n\n  /**\n   * Organization name associated with the pipeline\n   */\n  readonly organization?: string;\n\n  /**\n   * Pipeline name to filter by\n   */\n  readonly pipelineName?: string;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n}\n\n/** Filter interface for pipeline-template queries (golden-path catalog). */\nexport interface PipelineTemplateFilter extends CommonFilter {\n  /** Template name (case-insensitive contains). */\n  readonly name?: string;\n  /** Category to filter by (e.g. 'language', 'general'). */\n  readonly category?: string;\n  /** Keyword search within the keywords JSONB array. */\n  readonly keyword?: string;\n  // Sharing rung + viewer context are inherited from CommonFilter.\n}\n\n/**\n * Filter interface for message-specific properties.\n * Extends CommonFilter to include message-related filter options.\n */\nexport interface MessageFilter extends CommonFilter {\n  /**\n   * Thread ID to filter by (for fetching thread replies).\n   * Pass `null` to filter for root messages only (threadId IS NULL).\n   */\n  readonly threadId?: string | null;\n\n  /**\n   * Recipient organization ID to filter by\n   * Use '*' for broadcast announcements\n   */\n  readonly recipientOrgId?: string;\n\n  /**\n   * Recipient user ID to filter by (per-user targeting within the recipient\n   * org). Pass `null` to match org-wide messages only (recipient_user_id IS\n   * NULL). Rarely set directly by callers — see `viewerUserId` for the\n   * visibility-scoping variant.\n   */\n  readonly recipientUserId?: string | null;\n\n  // NOTE: the VIEWER's user id (`viewerUserId`) is inherited from CommonFilter.\n  // For messages it is NOT a column filter: when present, the recipient-side\n  // branch in `buildMessageConditions` widens to include rows targeted at this\n  // user (recipient_user_id = viewerUserId) ALONGSIDE org-wide ones\n  // (recipient_user_id IS NULL). When absent, only org-wide recipient rows are\n  // visible, so a user-targeted message stays private to its target, the sender,\n  // and the system org. MessageService stamps it from the tenant context.\n\n  /**\n   * Message type filter\n   */\n  readonly messageType?: 'announcement' | 'conversation';\n\n  /**\n   * Filter by priority level\n   */\n  readonly priority?: 'normal' | 'high' | 'urgent';\n\n  /**\n   * Channel/inbox-bucket filter (e.g. 'support', 'help'). Matches rows\n   * exactly; pass null to match channel IS NULL (org-to-org messages).\n   */\n  readonly channel?: string | null;\n\n  /**\n   * Filter by read state for the requesting org.\n   * Implemented as a JSONB key-existence check against `messages.read_by`\n   * (a `{ [orgId]: isoTimestamp }` map), using the orgId passed to\n   * `buildMessageConditions`.\n   * - true  → only messages the org has read (orgId key exists in read_by)\n   * - false → only messages the org has NOT read\n   * - undefined → no read-state filter\n   */\n  readonly isRead?: boolean;\n\n  /**\n   * Free-text inbox search. Case-insensitive substring match against the\n   * message `subject` OR `content` (LIKE wildcards in the term are escaped, so a\n   * literal `%`/`_` matches itself). Applied on top of the visibility scope, so\n   * it never widens what the caller can see.\n   */\n  readonly search?: string;\n}\n\n// ========================================\n// Compliance Filters\n// ========================================\n\n/**\n * Filter for compliance policies.\n */\nexport interface CompliancePolicyFilter extends CommonFilter {\n  readonly name?: string;\n  readonly isTemplate?: boolean;\n}\n\n/**\n * Filter for compliance rules.\n */\nexport interface ComplianceRuleFilter extends CommonFilter {\n  readonly name?: string;\n  readonly policyId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly field?: string;\n  readonly severity?: 'warning' | 'error' | 'critical';\n  readonly scope?: 'org' | 'published';\n  readonly tag?: string;\n}\n\n/**\n * Filter for compliance exemptions.\n */\nexport interface ComplianceExemptionFilter {\n  readonly orgId?: string;\n  readonly ruleId?: string;\n  readonly entityType?: 'plugin' | 'pipeline';\n  readonly entityId?: string;\n  readonly status?: 'pending' | 'approved' | 'rejected' | 'expired';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance audit log entries.\n */\nexport interface ComplianceAuditFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly action?: string;\n  readonly result?: 'pass' | 'warn' | 'block';\n  readonly scanId?: string;\n  readonly dateFrom?: string;\n  readonly dateTo?: string;\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance scans.\n */\nexport interface ComplianceScanFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline' | 'all';\n  readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';\n  readonly triggeredBy?: 'manual' | 'scheduled' | 'rule-change' | 'rule-dry-run';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n"]}