pi-lens 4.3.0 → 4.4.1

package/dist/clients/dispatch/lazy.js

@@ -1,11 +0,0 @@
-/** Lazy dispatch integration seam for startup-cost control (#1394). */
-import { createLazyImport } from "../lazy-import.js";
-const lazyIntegration = createLazyImport(() => import("./integration.js"));
-/** Start loading the runner graph once; callers may fire-and-forget this. */
-export function warmDispatchIntegration() {
-    return lazyIntegration.get();
-}
-/** Await the same promise used by session-start warming and first use. */
-export function loadDispatchIntegration() {
-    return warmDispatchIntegration();
-}

package/dist/clients/dispatch/pending-runner-findings.js

@@ -1,87 +0,0 @@
-/** Turn-end handoff for runners moved off the post-write critical path. */
-import { incrementDegradationCount } from "../degradation-ledger.js";
-const pending = [];
-const MAX_PENDING_RUNNER_FINDINGS = 50;
-export function deferRunnerFindings(entry) {
-    const tracked = { ...entry, settled: false };
-    // Attach exactly once at ownership time. Re-attaching at every turn end
-    // accumulates handlers on a promise that may never settle (#2122 F8).
-    void tracked.promise.then((result) => {
-        tracked.result = result;
-        tracked.settled = true;
-    }, (error) => {
-        tracked.result = {
-            status: "failed",
-            diagnostics: [],
-            semantic: "warning",
-            failureKind: "exception",
-            failureMessage: String(error).slice(0, 200),
-        };
-        tracked.settled = true;
-    });
-    pending.push(tracked);
-    if (pending.length > MAX_PENDING_RUNNER_FINDINGS) {
-        const evicted = pending.shift();
-        if (evicted) {
-            incrementDegradationCount({
-                kind: "runner-findings-evicted",
-                subject: `${evicted.runnerId}:${evicted.filePath}`,
-                reason: `pending runner cap ${MAX_PENDING_RUNNER_FINDINGS}`,
-            });
-        }
-    }
-}
-/**
- * Resolve already-finished runner work for this turn. Unfinished work remains
- * owned by the store and is retried at the next turn boundary.
- */
-export async function drainPendingRunnerFindings(maxWaitMs = 2_000) {
-    if (pending.length === 0)
-        return [];
-    const current = pending.splice(0, pending.length);
-    const results = [];
-    // Give already-resolved promises one microtask turn without introducing a
-    // wall-clock wait. This observes completed work while preserving the F5
-    // zero-budget contract for in-flight runners.
-    if (maxWaitMs === 0)
-        await Promise.resolve();
-    if (maxWaitMs > 0 && current.some((entry) => !entry.settled)) {
-        await new Promise((resolve) => {
-            const timer = setTimeout(resolve, maxWaitMs);
-            timer.unref?.();
-        });
-    }
-    for (const entry of current) {
-        if (entry.settled && entry.result) {
-            results.push({
-                filePath: entry.filePath,
-                cwd: entry.cwd,
-                projectRoot: entry.projectRoot,
-                runnerId: entry.runnerId,
-                markedAtMs: entry.markedAtMs,
-                writeIndex: entry.writeIndex,
-                result: entry.result,
-            });
-        }
-        else {
-            pending.push(entry);
-        }
-    }
-    return results;
-}
-/** Drop a stale answer and record the lost re-run coverage. */
-export function dropStaleRunnerFindings(entry) {
-    if (!entry.result)
-        return;
-    incrementDegradationCount({
-        kind: "runner-findings-stale",
-        subject: `${entry.runnerId}:${entry.filePath}`,
-        reason: "completed result was older than the latest file edit",
-    });
-}
-export function resetPendingRunnerFindings() {
-    pending.length = 0;
-}
-export function pendingRunnerFindingsSize() {
-    return pending.length;
-}

package/dist/clients/dispatch/plan.js

@@ -1,278 +0,0 @@
-import { getPrimaryDispatchGroup } from "../language-policy.js";
-function primary(kind) {
-    const group = getPrimaryDispatchGroup(kind, true);
-    if (!group) {
-        throw new Error(`Missing primary dispatch group for ${kind}`);
-    }
-    return group;
-}
-export const LANGUAGE_CAPABILITY_MATRIX = {
-    jsts: {
-        name: "JavaScript/TypeScript Linting",
-        capabilities: ["types", "security", "smells", "format", "lint"],
-        writeGroups: [
-            primary("jsts"),
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["jsts"] },
-            { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["jsts"] },
-            { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["jsts"] },
-            {
-                mode: "fallback",
-                runnerIds: ["eslint", "oxlint", "biome-check-json"],
-                filterKinds: ["jsts"],
-            },
-        ],
-    },
-    python: {
-        name: "Python Linting",
-        capabilities: ["types", "lint", "smells"],
-        writeGroups: [
-            primary("python"),
-            { mode: "fallback", runnerIds: ["ruff-lint"], filterKinds: ["python"] },
-            { mode: "fallback", runnerIds: ["mypy"], filterKinds: ["python"] },
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["python"] },
-            { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["python"] },
-        ],
-    },
-    go: {
-        name: "Go Linting",
-        capabilities: ["types", "lint", "smells"],
-        writeGroups: [
-            primary("go"),
-            { mode: "fallback", runnerIds: ["golangci-lint"], filterKinds: ["go"] },
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["go"] },
-            { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["go"] },
-        ],
-    },
-    rust: {
-        name: "Rust Linting",
-        capabilities: ["types", "lint", "smells"],
-        writeGroups: [
-            primary("rust"),
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["rust"] },
-            { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["rust"] },
-        ],
-    },
-    ruby: {
-        name: "Ruby Linting",
-        capabilities: ["types", "lint", "smells"],
-        writeGroups: [
-            primary("ruby"),
-            { mode: "fallback", runnerIds: ["rubocop"], filterKinds: ["ruby"] },
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["ruby"] },
-            { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["ruby"] },
-        ],
-    },
-    cxx: {
-        name: "C/C++ Linting",
-        capabilities: ["types", "lint", "smells"],
-        writeGroups: [
-            primary("cxx"),
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["cxx"] },
-        ],
-    },
-    cmake: {
-        name: "CMake Processing",
-        capabilities: ["lint"],
-        writeGroups: [
-            primary("cmake"),
-            { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["cmake"] },
-        ],
-    },
-    fish: {
-        name: "Fish Script Formatting",
-        capabilities: ["format"],
-        writeGroups: [primary("fish")],
-    },
-    shell: {
-        name: "Shell Script Linting",
-        capabilities: ["lint", "security", "format"],
-        writeGroups: [
-            primary("shell"),
-            { mode: "all", runnerIds: ["shfmt"], filterKinds: ["shell"] },
-            { mode: "all", runnerIds: ["fact-rules"], filterKinds: ["shell"] },
-        ],
-    },
-    json: {
-        name: "JSON Processing",
-        capabilities: ["format", "lint"],
-        writeGroups: [
-            primary("json"),
-            { mode: "all", runnerIds: ["trivy-config"], filterKinds: ["json"] },
-        ],
-    },
-    markdown: {
-        name: "Markdown Processing",
-        capabilities: ["docs", "format", "lint"],
-        writeGroups: [
-            primary("markdown"),
-            { mode: "all", runnerIds: ["markdownlint"], filterKinds: ["markdown"] },
-        ],
-    },
-    css: {
-        name: "CSS Processing",
-        capabilities: ["format", "lint"],
-        writeGroups: [
-            primary("css"),
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["css"] },
-            { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["css"] },
-        ],
-    },
-    yaml: {
-        name: "YAML Processing",
-        capabilities: ["format", "lint"],
-        writeGroups: [
-            primary("yaml"),
-            { mode: "all", runnerIds: ["actionlint"], filterKinds: ["yaml"] },
-        ],
-    },
-    "helm-template": {
-        name: "Helm Template Linting",
-        capabilities: ["lint"],
-        writeGroups: [primary("helm-template")],
-    },
-    sql: {
-        name: "SQL Processing",
-        capabilities: ["format", "lint"],
-        writeGroups: [primary("sql")],
-    },
-    html: {
-        name: "HTML Linting",
-        capabilities: ["lint"],
-        writeGroups: [
-            primary("html"),
-            { mode: "all", runnerIds: ["ast-grep-napi"], filterKinds: ["html"] },
-        ],
-    },
-    docker: {
-        name: "Dockerfile Linting",
-        capabilities: ["lint"],
-        writeGroups: [primary("docker")],
-    },
-    php: {
-        name: "PHP Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [
-            primary("php"),
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["php"] },
-        ],
-    },
-    powershell: {
-        name: "PowerShell Linting",
-        capabilities: ["lint"],
-        writeGroups: [primary("powershell")],
-    },
-    prisma: {
-        name: "Prisma Schema Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("prisma")],
-    },
-    csharp: {
-        name: "C# Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [
-            primary("csharp"),
-            { mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["csharp"] },
-        ],
-    },
-    fsharp: {
-        name: "F# Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("fsharp")],
-    },
-    java: {
-        name: "Java Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("java")],
-    },
-    kotlin: {
-        name: "Kotlin Linting",
-        capabilities: ["types", "lint", "format", "smells"],
-        writeGroups: [
-            primary("kotlin"),
-            { mode: "fallback", runnerIds: ["detekt"], filterKinds: ["kotlin"] },
-        ],
-    },
-    swift: {
-        name: "Swift Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("swift")],
-    },
-    dart: {
-        name: "Dart Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("dart")],
-    },
-    lua: {
-        name: "Lua Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("lua")],
-    },
-    zig: {
-        name: "Zig Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("zig")],
-    },
-    haskell: {
-        name: "Haskell Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("haskell")],
-    },
-    elixir: {
-        name: "Elixir Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("elixir")],
-    },
-    gleam: {
-        name: "Gleam Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("gleam")],
-    },
-    ocaml: {
-        name: "OCaml Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("ocaml")],
-    },
-    clojure: {
-        name: "Clojure Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("clojure")],
-    },
-    cue: {
-        name: "CUE Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("cue")],
-    },
-    terraform: {
-        name: "Terraform Linting",
-        capabilities: ["types", "lint", "security"],
-        writeGroups: [primary("terraform")],
-    },
-    terragrunt: {
-        name: "Terragrunt Linting",
-        capabilities: ["lint", "format"],
-        writeGroups: [primary("terragrunt")],
-    },
-    nix: {
-        name: "Nix Linting",
-        capabilities: ["types", "lint"],
-        writeGroups: [primary("nix")],
-    },
-    toml: {
-        name: "TOML Linting",
-        capabilities: ["lint", "format"],
-        writeGroups: [primary("toml")],
-    },
-};
-function toWritePlan(entry) {
-    return {
-        name: entry.name,
-        groups: [...entry.writeGroups],
-    };
-}
-export const TOOL_PLANS = Object.fromEntries(Object.entries(LANGUAGE_CAPABILITY_MATRIX).map(([kind, entry]) => [
-    kind,
-    toWritePlan(entry),
-]));
-export function getToolPlan(kind) {
-    return TOOL_PLANS[kind];
-}

package/dist/clients/dispatch/priorities.js

@@ -1,20 +0,0 @@
-/**
- * Dispatch runner priority tiers.
- *
- * NOTE: These priorities only govern ordering within dispatch runner execution.
- * They do not represent full write/edit pipeline order.
- */
-export const PRIORITY = {
-    LSP_PRIMARY: 4,
-    LSP_FALLBACK: 5,
-    FORMAT_AND_LINT_PRIMARY: 10,
-    LINT_SECONDARY: 12,
-    STRUCTURAL_ANALYSIS: 14,
-    SPECIALIZED_ANALYSIS: 15,
-    GENERAL_ANALYSIS: 20,
-    YAML_LINT: 22,
-    SQL_LINT: 24,
-    DOC_QUALITY: 30,
-    ARCHITECTURE: 40,
-    DEEP_LANGUAGE_ANALYSIS: 50,
-};

package/dist/clients/dispatch/rule-id-normalize.js

@@ -1,50 +0,0 @@
-/**
- * Normalize a rule id to the form a user typically writes in a
- * `pi-lens-ignore` comment, an inline suppression, or a project-level
- * `disable`/`select` list. Strips the `ast-grep:` LSP source prefix and the
- * language suffix used by the rule catalogs.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getAstGrepRuleSources } from "../sgconfig.js";
-/** Derive language tags from shipped rule filenames, rather than a list. */
-export function deriveRuleIdLanguageSuffixes(ruleRoot) {
-    const suffixes = new Set();
-    const visit = (dir) => {
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const entryPath = path.join(dir, entry.name);
-            if (entry.isDirectory())
-                visit(entryPath);
-            else {
-                const match = /-([a-z0-9]+)\.ya?ml$/i.exec(entry.name);
-                if (match)
-                    suffixes.add(match[1].toLowerCase());
-            }
-        }
-    };
-    visit(ruleRoot);
-    return suffixes;
-}
-const bundledCodeRabbitRules = getAstGrepRuleSources().find((source) => source.origin === "bundled" && source.tier === "secondary");
-const RULE_ID_LANGUAGE_SUFFIXES = new Set(["js"]);
-if (bundledCodeRabbitRules) {
-    for (const suffix of deriveRuleIdLanguageSuffixes(bundledCodeRabbitRules.dir)) {
-        RULE_ID_LANGUAGE_SUFFIXES.add(suffix);
-    }
-}
-export function normalizeRuleId(ruleId) {
-    const normalized = ruleId.replace(/^ast-grep:/, "");
-    for (const suffix of RULE_ID_LANGUAGE_SUFFIXES) {
-        if (normalized.endsWith(`-${suffix}`)) {
-            return normalized.slice(0, -(suffix.length + 1));
-        }
-    }
-    return normalized;
-}

package/dist/clients/dispatch/rule-ignores.js

@@ -1,69 +0,0 @@
-/**
- * Per-rule path carve-outs (`ignores:` in a rule's own YAML, #965).
- *
- * ONE matcher, shared by every surface that decides whether a rule may fire on
- * a path: the NAPI ast-grep runner, the tree-sitter runner (`ignore_paths`),
- * and — since #3041 — the LSP output seam (`applyAuxiliarySuppressions`).
- *
- * #3041, measured against ast-grep 0.45.3: `ast-grep scan` applies a rule's
- * `ignores` globs during its own project walk, but `ast-grep lsp` publishes
- * per-document diagnostics WITHOUT applying them — the same rule on the same
- * file is filtered by the CLI and unfiltered over LSP. So every pi-lens path
- * that delivers ast-grep's LSP diagnostics has to apply the carve-out itself;
- * the runner-side matcher below is what it applies.
- */
-import * as path from "node:path";
-import { minimatch } from "../deps/minimatch.js";
-import { buildEffectiveAstGrepCatalog } from "./ast-grep-catalog.js";
-import { isWindowsPath, toPosix } from "../path-utils.js";
-/**
- * True when `filePath` is carved out of a rule by one of its glob `patterns`.
- *
- * The glob is matched against `filePath` relative to `root`, forward-slashed.
- * Falls back to the absolute (slash-normalized) path when `filePath` isn't
- * under `root` (e.g. an out-of-tree temp file). Leaf-file patterns retain that
- * fallback for sinks such as a double-star logger leaf; directory carve-outs
- * ending in a slash plus double-star remain root-contained so a project's CLI
- * exemption cannot suppress a finding in an unrelated out-of-tree file.
- */
-export function isRuleIgnoredForPath(filePath, root, patterns) {
-    if (!patterns || patterns.length === 0)
-        return false;
-    const pathApi = isWindowsPath(root) || isWindowsPath(filePath) ? path.win32 : path.posix;
-    const relative = pathApi.relative(root, filePath);
-    const outsideRoot = relative !== "" &&
-        (relative === ".." ||
-            relative.startsWith(`..${pathApi.sep}`) ||
-            pathApi.isAbsolute(relative));
-    const displayPath = toPosix(outsideRoot ? filePath : relative);
-    return patterns.some((pattern) => (!outsideRoot || !pattern.replaceAll("\\", "/").endsWith("/**")) &&
-        minimatch(displayPath, pattern, { dot: true }));
-}
-/**
- * Rule id → its `ignores` globs, for the effective ast-grep catalog at `root`.
- *
- * #3053: the catalog walk and its first-source-wins precedence used to be
- * reimplemented here; both this function and the NAPI runner now read
- * `buildEffectiveAstGrepCatalog` (clients/dispatch/ast-grep-catalog.ts), so
- * the LSP seam carves out exactly the paths the runner carves out by
- * construction rather than by two hand-aligned copies — see that module's
- * docstring for the precedence rule and the within-source-duplicate decision
- * this function inherits from it. The catalog's own loaders are cached, so
- * this is ~0.09 ms per call on pi-lens's own catalog (17 rules with
- * `ignores`, measured) — cheap enough to call per file rather than thread a
- * preloaded map through every sweep.
- *
- * Keyed by the EXACT rule id, matching the runner: a `-js` twin (e.g.
- * `no-console-except-error-js`) carries its own `ignores` in its own document,
- * so normalizing the suffix here would apply one document's carve-out to the
- * other's findings.
- */
-export function loadRuleIgnorePatterns(root) {
-    const patterns = new Map();
-    for (const [id, { rule }] of buildEffectiveAstGrepCatalog(root)
-        .effectiveRules) {
-        if (rule.ignores?.length)
-            patterns.set(id, rule.ignores);
-    }
-    return patterns;
-}

package/dist/clients/dispatch/rule-policy.js

@@ -1,135 +0,0 @@
-/**
- * Project-level rule policy (`.pi-lens.json` `rules.<id>.disable` /
- * `rules.<id>.select`) — output-only filtering of dispatches, so the project's
- * own policy narrows what the user actually sees without widening the trusted
- * surface area (widget state, baseline, dedup, and per-edit record stay
- * authoritative).
- *
- * Matching is PROJECT-WIDE. The outer `rules.<key>` is a grouping label only —
- * it does not scope which diagnostics a `disable`/`select` list under it can
- * match. Every `disable` entry across every key is unioned into one drop list,
- * and every `select` entry across every key is unioned into one allowlist.
- * Disable is checked first, so it wins globally regardless of which key it's
- * configured under.
- *
- * Match normalization is consolidated with the rest of the rule-id surfaces:
- * `inline-suppressions.ts` and `lens-diagnostics.ts`'s `normalizeRuleId`
- * both strip the `ast-grep:` prefix and the `-js` suffix, so a user listing
- * `no-eval` once under `disable` covers both the LSP tag (`ast-grep:no-eval`)
- * and the napi tag (`no-eval` / `no-eval-js`). Sharing the normalization keeps
- * the three surfaces from drifting.
- */
-import { normalizeRuleId } from "./rule-id-normalize.js";
-/**
- * Decide whether a rule id (in the form it's emitted on a diagnostic — e.g.
- * `ast-grep:no-eval`, `no-eval-js`, `no-eval`, `ts:2322`) should be filtered
- * out under a project's rule policy map. Returns `dropped: true` when the
- * diagnostic would be hidden from output.
- *
- * Project-wide: every `disable` entry across every configured key is checked
- * first (disable wins globally over select). Then every `select` entry
- * across every key is unioned into one allowlist — a non-empty union that
- * the rule doesn't match also drops it. An absent/empty union across all
- * keys means "no restriction". Matching uses the same normalization as
- * inline suppression so a configured `no-eval` entry covers
- * `ast-grep:no-eval` and `no-eval-js`.
- */
-export function evaluateRulePolicy(ruleId, policyMap) {
-    if (!policyMap)
-        return { dropped: false };
-    const raw = ruleId || "";
-    const norm = normalizeRuleId(raw);
-    if (scanList(policyMap, (e) => e.disable, raw, norm).matched) {
-        return { dropped: true };
-    }
-    const select = scanList(policyMap, (e) => e.select, raw, norm);
-    return { dropped: select.sawEntry && !select.matched };
-}
-/**
- * Union one list (`disable` or `select`) across every key in the map and test
- * the rule against it. `sawEntry` reports whether the union was non-empty,
- * which is what makes a `select` union restrictive rather than absent.
- */
-function scanList(policyMap, pick, raw, norm) {
-    let sawEntry = false;
-    for (const entry of Object.values(policyMap)) {
-        for (const candidate of (entry && pick(entry)) ?? []) {
-            sawEntry = true;
-            if (matchesRule(candidate, raw, norm))
-                return { matched: true, sawEntry };
-        }
-    }
-    return { matched: false, sawEntry };
-}
-function matchesRule(entry, raw, normalized) {
-    if (entry === raw)
-        return true;
-    return normalizeRuleId(entry) === normalized;
-}
-/**
- * Filter an array of diagnostics (returns a new array) by the project rule
- * policy map. `rule` is preferred; code-only diagnostics use `code` as their
- * policy key so project-diagnostics details and rendered summaries cannot
- * disagree about a finding that has no explicit rule field. `Diagnostic.id`
- * remains a dedup key (`eslint:unknown:12`), not a policy key, so id-only
- * findings (including blocking parse errors) remain exempt.
- *
- * Used by both the per-edit dispatcher and the `lens-diagnostics` tool's
- * `mode=delta`/`mode=all`/`mode=full` paths so a project's own policy
- * applies consistently across every output surface.
- */
-export function applyRulePolicy(diagnostics, policyMap) {
-    if (!policyMap)
-        return diagnostics;
-    // Fast-path: if every entry has neither disable nor select, there is no
-    // output filter to apply. Keeps the hot path (most projects have only
-    // thresholds) cheap.
-    let hasFilter = false;
-    for (const rawEntry of Object.values(policyMap)) {
-        if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-            continue;
-        }
-        const entry = rawEntry;
-        if ((entry.disable?.length ?? 0) > 0 || (entry.select?.length ?? 0) > 0) {
-            hasFilter = true;
-            break;
-        }
-    }
-    if (!hasFilter)
-        return diagnostics;
-    return diagnostics.filter((d) => {
-        const ruleId = d.rule ?? d.code;
-        if (!ruleId)
-            return true;
-        const { dropped } = evaluateRulePolicy(ruleId, policyMap);
-        return !dropped;
-    });
-}
-/**
- * Build the policy map from a `PiLensProjectConfig.rules`-shaped value. Returns
- * undefined when there's nothing to filter (the hot path), or a map suitable
- * for `applyRulePolicy` otherwise. Excludes entries whose only field is
- * `threshold` (a threshold is a separate concern handled elsewhere) so the
- * filter step doesn't repeat the work.
- */
-export function rulePolicyMapFromConfig(rules) {
-    if (!rules)
-        return undefined;
-    let built;
-    for (const [key, rawEntry] of Object.entries(rules)) {
-        if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-            continue;
-        }
-        const entry = rawEntry;
-        const hasDisable = (entry.disable?.length ?? 0) > 0;
-        const hasSelect = (entry.select?.length ?? 0) > 0;
-        if (!hasDisable && !hasSelect)
-            continue;
-        built ??= {};
-        built[key] = {
-            ...(hasDisable ? { disable: entry.disable } : {}),
-            ...(hasSelect ? { select: entry.select } : {}),
-        };
-    }
-    return built;
-}