@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/complexity-client.js

@@ -1,462 +0,0 @@
-/**
- * Complexity Metrics Client for pi-lens
- *
- * Language-agnostic AST-based code complexity metrics, computed over the shared
- * tree-sitter client (#402 — no `typescript` compiler dependency). Supported
- * grammars are keyed in LANGUAGE_NODES (JS/TS, Python, Go, Rust today; adding a
- * language is one table entry).
- *
- * Tracks: max nesting depth, function length, cyclomatic + cognitive complexity,
- * maintainability index (Halstead-free), LOC/comments, code entropy, and AI-slop
- * indicators. These are silent metrics surfaced in the session summary.
- */
-import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { calcCyclomaticComplexity } from "./dispatch/facts/function-facts.js";
-import { firstChildOfType, withTreeSitterRoot, isComplexityLanguageId, isComplexitySupportedFile, resolveTreeSitterLanguage, walk, } from "./tree-sitter-shared.js";
-// JS/TS/JSX share one grammar shape.
-const JSTS = {
-    functionLike: new Set([
-        "function_declaration",
-        "method_definition",
-        "function_expression",
-        "arrow_function",
-        "generator_function",
-        "generator_function_declaration",
-    ]),
-    nesting: new Set([
-        "if_statement",
-        "while_statement",
-        "for_statement",
-        "for_in_statement",
-        "switch_statement",
-        "function_declaration",
-        "function_expression",
-        "arrow_function",
-        "method_definition",
-        "class_declaration",
-        "try_statement",
-        "catch_clause",
-    ]),
-    decision: new Set([
-        "if_statement",
-        "while_statement",
-        "for_statement",
-        "for_in_statement",
-        "switch_case",
-        "ternary_expression",
-    ]),
-    cognitive: new Set([
-        "if_statement",
-        "while_statement",
-        "for_statement",
-        "for_in_statement",
-        "switch_statement",
-        "switch_case",
-        "ternary_expression",
-        "catch_clause",
-    ]),
-    logicalOpNodes: new Set(),
-    logicalBinaryOps: new Set(["&&", "||", "??"]),
-    tryNode: "try_statement",
-    nameChildTypes: ["identifier", "property_identifier"],
-};
-const PYTHON = {
-    functionLike: new Set(["function_definition", "lambda"]),
-    nesting: new Set([
-        "if_statement",
-        "for_statement",
-        "while_statement",
-        "match_statement",
-        "function_definition",
-        "class_definition",
-        "try_statement",
-        "except_clause",
-        "elif_clause",
-    ]),
-    decision: new Set([
-        "if_statement",
-        "elif_clause",
-        "for_statement",
-        "while_statement",
-        "case_clause",
-        "conditional_expression",
-    ]),
-    cognitive: new Set([
-        "if_statement",
-        "elif_clause",
-        "for_statement",
-        "while_statement",
-        "match_statement",
-        "case_clause",
-        "conditional_expression",
-        "except_clause",
-    ]),
-    logicalOpNodes: new Set(["boolean_operator"]),
-    logicalBinaryOps: new Set(),
-    tryNode: "try_statement",
-    nameChildTypes: ["identifier"],
-};
-const GO = {
-    functionLike: new Set([
-        "function_declaration",
-        "method_declaration",
-        "func_literal",
-    ]),
-    nesting: new Set([
-        "if_statement",
-        "for_statement",
-        "expression_switch_statement",
-        "type_switch_statement",
-        "select_statement",
-        "function_declaration",
-        "method_declaration",
-    ]),
-    decision: new Set([
-        "if_statement",
-        "for_statement",
-        "expression_case",
-        "type_case",
-        "communication_case",
-    ]),
-    cognitive: new Set([
-        "if_statement",
-        "for_statement",
-        "expression_switch_statement",
-        "type_switch_statement",
-        "select_statement",
-        "expression_case",
-        "type_case",
-        "communication_case",
-    ]),
-    logicalOpNodes: new Set(),
-    logicalBinaryOps: new Set(["&&", "||"]),
-    tryNode: undefined, // Go has no try/catch (error returns)
-    nameChildTypes: ["identifier", "field_identifier"],
-};
-const RUST = {
-    functionLike: new Set(["function_item", "closure_expression"]),
-    nesting: new Set([
-        "if_expression",
-        "while_expression",
-        "for_expression",
-        "loop_expression",
-        "match_expression",
-        "function_item",
-    ]),
-    decision: new Set([
-        "if_expression",
-        "while_expression",
-        "for_expression",
-        "loop_expression",
-        "match_arm",
-    ]),
-    cognitive: new Set([
-        "if_expression",
-        "while_expression",
-        "for_expression",
-        "loop_expression",
-        "match_expression",
-        "match_arm",
-    ]),
-    logicalOpNodes: new Set(),
-    logicalBinaryOps: new Set(["&&", "||"]),
-    tryNode: undefined, // Rust uses Result/? — no try/catch
-    nameChildTypes: ["identifier"],
-};
-/**
- * Node configuration per grammar. Keyed by {@link ComplexityLanguageId}, whose
- * list lives in `tree-sitter-shared.ts` so `isComplexitySupportedFile` can
- * answer without loading this module (#2467). `Record` over a finite union
- * requires EXACTLY these keys, so the two cannot drift.
- */
-const LANGUAGE_NODES = {
-    typescript: JSTS,
-    tsx: JSTS,
-    javascript: JSTS,
-    python: PYTHON,
-    go: GO,
-    rust: RUST,
-};
-const COMMENT_TYPES = new Set(["comment", "line_comment", "block_comment"]);
-// --- Metric helpers (module-level, node-config-driven) ---
-function isLogicalOp(node, nodes) {
-    if (nodes.logicalOpNodes.has(node.type))
-        return true;
-    if (nodes.logicalBinaryOps.size > 0 && node.type === "binary_expression") {
-        return (node.children ?? []).some((c) => c && nodes.logicalBinaryOps.has(c.type));
-    }
-    return false;
-}
-/** Cyclomatic contribution of a subtree: decision points + logical operators. */
-function subtreeCyclomatic(root, nodes) {
-    // Dispatch uses 1-based McCabe; this client exposes 0-based contributions (#2697).
-    if (nodes === JSTS)
-        return calcCyclomaticComplexity(root) - 1;
-    let cc = 0;
-    walk(root, (n) => {
-        if (nodes.decision.has(n.type))
-            cc++;
-        if (isLogicalOp(n, nodes))
-            cc++;
-    });
-    return cc;
-}
-/** Cognitive complexity (SonarSource-style: base + nesting penalty). */
-function subtreeCognitive(node, nesting, nodes) {
-    let complexity = 0;
-    if (nodes.cognitive.has(node.type))
-        complexity += 1 + nesting;
-    // Labeled break/continue add complexity.
-    if ((node.type === "break_statement" || node.type === "continue_statement") &&
-        (node.children ?? []).some((c) => c &&
-            (c.type === "statement_identifier" ||
-                c.type === "identifier" ||
-                c.type === "label_name" ||
-                c.type === "label"))) {
-        complexity += 1 + nesting;
-    }
-    if (isLogicalOp(node, nodes))
-        complexity += 1;
-    const childNesting = nodes.nesting.has(node.type) ? nesting + 1 : nesting;
-    for (const child of node.children ?? []) {
-        if (child)
-            complexity += subtreeCognitive(child, childNesting, nodes);
-    }
-    return complexity;
-}
-function subtreeMaxNesting(node, currentDepth, nodes) {
-    let maxDepth = currentDepth;
-    if (nodes.nesting.has(node.type)) {
-        currentDepth++;
-        maxDepth = Math.max(maxDepth, currentDepth);
-    }
-    for (const child of node.children ?? []) {
-        if (child) {
-            maxDepth = Math.max(maxDepth, subtreeMaxNesting(child, currentDepth, nodes));
-        }
-    }
-    return maxDepth;
-}
-function functionName(fnNode, nodes) {
-    for (const t of nodes.nameChildTypes) {
-        const id = firstChildOfType(fnNode, t);
-        if (id)
-            return id.text;
-    }
-    return undefined;
-}
-function collectFunctionMetrics(root, nodes) {
-    const functions = [];
-    const visit = (node, nestingLevel) => {
-        if (nodes.functionLike.has(node.type)) {
-            const startLine = node.startPosition.row;
-            const endLine = node.endPosition.row;
-            functions.push({
-                name: functionName(node, nodes) ?? `<anonymous@L${startLine + 1}>`,
-                line: startLine + 1,
-                length: endLine - startLine + 1,
-                cyclomatic: subtreeCyclomatic(node, nodes),
-                cognitive: subtreeCognitive(node, nestingLevel, nodes),
-                nestingDepth: subtreeMaxNesting(node, 0, nodes),
-            });
-        }
-        const newNesting = nodes.nesting.has(node.type)
-            ? nestingLevel + 1
-            : nestingLevel;
-        for (const child of node.children ?? []) {
-            if (child)
-                visit(child, newNesting);
-        }
-    };
-    visit(root, 0);
-    return functions;
-}
-function countTryCatch(root, nodes) {
-    if (!nodes.tryNode)
-        return 0;
-    let count = 0;
-    walk(root, (n) => {
-        if (n.type === nodes.tryNode)
-            count++;
-    });
-    return count;
-}
-function countLines(content, root) {
-    const lines = content.split(/\r?\n/);
-    const commentLineSet = new Set();
-    walk(root, (n) => {
-        if (COMMENT_TYPES.has(n.type)) {
-            for (let l = n.startPosition.row; l <= n.endPosition.row; l++) {
-                commentLineSet.add(l);
-            }
-        }
-    });
-    const codeLines = lines.filter((line, i) => {
-        if (line.trim().length === 0)
-            return false;
-        if (!commentLineSet.has(i))
-            return true;
-        // Line has a comment — keep it only if code remains after stripping it.
-        const stripped = line
-            .replace(/\/\/.*$/, "")
-            .replace(/\/\*[\s\S]*?\*\//g, "")
-            .replace(/#.*$/, "")
-            .trim();
-        return stripped.length > 0;
-    }).length;
-    return { codeLines, commentLines: commentLineSet.size };
-}
-const AI_COMMENT_PATTERNS = [
-    /(?:🔍|✅|📝|🔧|🐛|⚠️|🚀|💡|🎯|📌|🏷️|🔑|🏗️|🧪|🗑️|🔄|♻️|📋|🔖|📊|💬|🔥|💎|⭐|🌟|🎨|🛠️)/u,
-    /(?:\/\/|#)\s*(Initialize|Setup|Clean up|Create|Define|Check if|Handle|Process|Validate|Return|Get|Set|Add|Remove|Update|Fetch)\b/i,
-    /(?:\/\/|#)\s*(This function|This method|This code|Here we|Now we)\b/i,
-    /\/\*\*?\s*(Overview|Summary|Description|Example|Usage)\s*\*?\//i,
-];
-function countAICommentPatterns(sourceText) {
-    let count = 0;
-    for (const line of sourceText.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("//") ||
-            trimmed.startsWith("/*") ||
-            trimmed.startsWith("*") ||
-            trimmed.startsWith("#")) {
-            for (const pattern of AI_COMMENT_PATTERNS) {
-                if (pattern.test(line)) {
-                    count++;
-                    break;
-                }
-            }
-        }
-    }
-    return count;
-}
-function calculateCodeEntropy(sourceText) {
-    const tokens = sourceText
-        .replace(/\/\/.*/g, "")
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-        .replace(/["'`][^"'`]*["'`]/g, "STR")
-        .replace(/\b\d+(\.\d+)?\b/g, "NUM")
-        .split(/[\s\n\r\t,;:()[\]{}=<>!&|+\-*/%^~?]+/)
-        .filter((t) => t.length > 0);
-    if (tokens.length === 0)
-        return 0;
-    const freq = new Map();
-    for (const token of tokens)
-        freq.set(token, (freq.get(token) || 0) + 1);
-    let entropy = 0;
-    for (const count of freq.values()) {
-        const p = count / tokens.length;
-        if (p > 0)
-            entropy -= p * Math.log2(p);
-    }
-    return entropy;
-}
-/**
- * Maintainability index, Halstead-free variant:
- * MI = max(0, (171 - 0.23·Cyclomatic - 16.2·ln(LOC)) · 100/171) + comment bonus.
- */
-function calculateMaintainabilityIndex(cyclomatic, loc, comments) {
-    if (loc === 0)
-        return 100;
-    const lnLOC = Math.log(loc);
-    let mi = ((171 - 0.23 * cyclomatic - 16.2 * lnLOC) * 100) / 171;
-    const commentBonus = Math.min(10, (comments / loc) * 50);
-    mi += commentBonus;
-    return Math.max(0, Math.min(100, mi));
-}
-function calculateMaxParams(functions) {
-    // Estimate from average function length (kept from the original heuristic).
-    return Math.min(10, Math.max(2, Math.round(functions.reduce((a, f) => a + f.length, 0) /
-        Math.max(1, functions.length) /
-        5)));
-}
-function countSingleUseFunctions(functions) {
-    return functions.filter((f) => f.length < 10 &&
-        f.cyclomatic <= 2 &&
-        /^(get|set|check|is|has|validate|format|parse|convert|create|make)/i.test(f.name)).length;
-}
-// --- Client ---
-export class ComplexityClient {
-    log;
-    constructor(verbose = false) {
-        this.log = verbose ? createSubsystemLogger("complexity") : () => { };
-    }
-    /** True if the file's grammar has a complexity node mapping.
-     *
-     * Delegates to the module-free predicate in `tree-sitter-shared.ts`: the
-     * same question is asked by `handleToolCallImpl` BEFORE the analyzer
-     * bootstrap is loaded (#2467), and two copies of it would be two answers. */
-    isSupportedFile(filePath) {
-        return isComplexitySupportedFile(filePath);
-    }
-    /** Analyze complexity metrics for a file (null if unsupported / unparseable). */
-    async analyzeFile(filePath) {
-        const absolutePath = path.resolve(filePath);
-        const languageId = resolveTreeSitterLanguage(absolutePath);
-        const nodes = languageId && isComplexityLanguageId(languageId)
-            ? LANGUAGE_NODES[languageId]
-            : undefined;
-        if (!nodes)
-            return null;
-        let content;
-        try {
-            if (!fs.existsSync(absolutePath))
-                return null;
-            content = fs.readFileSync(absolutePath, "utf-8");
-        }
-        catch (err) {
-            this.log(`Read error for ${filePath}: ${err.message}`);
-            return null;
-        }
-        try {
-            const parsed = await withTreeSitterRoot(absolutePath, content, (root) => this.computeMetrics(absolutePath, content, root, nodes));
-            return parsed.parsed ? parsed.value : null;
-        }
-        catch (err) {
-            this.log(`Analysis error for ${filePath}: ${err.message}`);
-            return null;
-        }
-    }
-    computeMetrics(absolutePath, content, root, nodes) {
-        const { codeLines, commentLines } = countLines(content, root);
-        const functions = collectFunctionMetrics(root, nodes);
-        const maxNestingDepth = subtreeMaxNesting(root, 0, nodes);
-        const cognitive = subtreeCognitive(root, 0, nodes);
-        const funcStats = this.aggregateFunctionStats(functions);
-        return {
-            filePath: path.relative(process.cwd(), absolutePath),
-            maxNestingDepth,
-            avgFunctionLength: funcStats.avgLength,
-            maxFunctionLength: funcStats.maxLength,
-            functionCount: functions.length,
-            cyclomaticComplexity: funcStats.avgCyclomatic,
-            maxCyclomaticComplexity: funcStats.maxCyclomatic,
-            cognitiveComplexity: cognitive,
-            maintainabilityIndex: Math.round(calculateMaintainabilityIndex(funcStats.avgCyclomatic, codeLines, commentLines) * 10) / 10,
-            linesOfCode: codeLines,
-            commentLines,
-            codeEntropy: Math.round(calculateCodeEntropy(content) * 100) / 100,
-            maxParamsInFunction: calculateMaxParams(functions),
-            aiCommentPatterns: countAICommentPatterns(content),
-            singleUseFunctions: countSingleUseFunctions(functions),
-            tryCatchCount: countTryCatch(root, nodes),
-            functions,
-        };
-    }
-    aggregateFunctionStats(functions) {
-        if (functions.length === 0) {
-            return { avgLength: 0, maxLength: 0, avgCyclomatic: 1, maxCyclomatic: 1 };
-        }
-        const lengths = functions.map((f) => f.length);
-        const cyclomatics = functions.map((f) => f.cyclomatic);
-        const sum = (arr) => arr.reduce((a, b) => a + b, 0);
-        return {
-            avgLength: Math.round(sum(lengths) / lengths.length),
-            maxLength: Math.max(...lengths),
-            avgCyclomatic: Math.max(1, Math.round(sum(cyclomatics) / cyclomatics.length)),
-            maxCyclomatic: Math.max(1, Math.max(...cyclomatics)),
-        };
-    }
-}

package/node_modules/pi-lens/dist/clients/config-core/deny.js

@@ -1,221 +0,0 @@
-/**
- * Monotonic deny precedence (#2425, scope item 4; #2415 AC 3).
- *
- * Ordinary config values are last-tier-wins. Denials are not. A denial is a
- * SECURITY decision, and the tier that made it is usually the tier the user
- * actually controls, so the ordinary rule is exactly backwards for it: today a
- * repository can hand pi-lens a `.pi-lens.json` that re-enables a server the
- * user disabled globally, and nothing notices.
- *
- * The rule, in one sentence: a denial from an OPERATOR tier is never lifted, and
- * a denial from any other tier is lifted only by an explicit operator allow of
- * higher precedence. `provenance.ts` owns the three-way tier classification;
- * this module owns what it means.
- *
- * The third class is why the sentence says "any other tier" rather than "a repo
- * tier" (#2440 review finding F3). `builtin` is `default`, not `operator`: a
- * denial pi-lens itself ships is liftable by the person running pi-lens — their
- * global config, their environment, their command line — and remains unliftable
- * by anything that arrived with a checkout. Treating a shipped default as an
- * operator decision made it permanent for everyone, which is a hard-coded
- * decision rather than a default.
- *
- * The two shapes a denial takes (`schema.ts`'s `x-deny`):
- *
- * - `boolean-false` — `enabled: false`. Resolution below.
- * - `array-union` — `disabledServers: ["x"]`. The union of every tier's
- *   members, always. There is no vocabulary for UN-denying a member, so a
- *   nearer tier that omits one is expressing nothing, not an allow. This is the
- *   one place `x-merge-strategy` does not decide the outcome: a `replace`
- *   strategy still governs how the array is SPELLED across tiers, and the deny
- *   union still governs which members survive. A deny that a merge strategy
- *   could erase would not be monotonic.
- *
- * Pure functions over their arguments. No state, no ledger writes: a denial
- * being honored is the normal case, not a degradation.
- */
-import { isOperatorTier, tierPrecedence, } from "./provenance.js";
-function provenanceOfContribution(source, key) {
-    if (!source)
-        return undefined;
-    return {
-        tier: source.tier,
-        key,
-        ...(source.file === undefined ? {} : { file: source.file }),
-        ...(source.trust === undefined ? {} : { trust: source.trust }),
-    };
-}
-/** Build a provenance entry for a resolved deny leaf. */
-export function denyProvenance(contributions, resolution, key) {
-    return provenanceOfContribution(contributions[resolution.winner], key);
-}
-/**
- * One provenance entry per SURVIVING member of an `array-union`, keyed by the
- * member's own JSON pointer.
- *
- * The array's own entry still exists and still names the first denying tier;
- * these are strictly additional, so a consumer that asks about the array is
- * unaffected and a consumer that asks about a member gets the tier that
- * actually denied it (#2427 review round 2, F2).
- */
-export function denyMemberProvenance(contributions, resolution, key) {
-    const entries = [];
-    resolution.memberWinners.forEach((index, position) => {
-        const pointer = `${key}/${position}`;
-        const entry = provenanceOfContribution(contributions[index], pointer);
-        if (entry)
-            entries.push(entry);
-    });
-    return entries;
-}
-/** The `memberWinners` of a leaf with no members. One shared frozen empty. */
-const EMPTY_MEMBER_WINNERS = Object.freeze([]);
-/** Contributions sorted by tier precedence, lowest first, ties in caller order. */
-function byPrecedence(contributions) {
-    return contributions
-        .map((contribution, index) => ({ contribution, index }))
-        .sort((left, right) => tierPrecedence(left.contribution.tier) -
-        tierPrecedence(right.contribution.tier));
-}
-/**
- * Resolve a `boolean-false` deny.
- *
- * - No `false` anywhere: ordinary last-tier-wins.
- * - An OPERATOR tier said `false`: DENIED, pinned, unliftable by anything. The
- *   winner is the LOWEST-precedence operator denial, because that is the answer
- *   to "who denied this" — the first authority to say no, not the last tier to
- *   repeat it. This holds even for a nearer operator tier: `cli: true` does not
- *   lift `global: false`. The escape hatch for an operator who changes their
- *   mind is to change the operator-tier config that denied, not to out-rank it
- *   from another operator tier.
- * - Otherwise every denial came from `default` or `repo` tiers, and an OPERATOR
- *   tier ranked above the FIRST such denial lifts it by saying `true` outright.
- *   That is what makes a built-in default a default (`builtin: false` +
- *   `global: true` -> `true`) while keeping repository content out of the
- *   decision (`builtin: false` + `project: true` -> `false`). A repo tier never
- *   lifts anything, its own class included.
- *
- * The lift test asks `isOperatorTier`, NOT `!isRepoTier`. The negative spelling
- * is what silently swept `builtin` into the operator class and made every
- * shipped default permanent; the affirmative one cannot.
- *
- * Non-boolean contributions are ignored here: `normalize.ts` has already
- * dropped values that failed the schema, so anything left is a boolean.
- */
-export function resolveBooleanDeny(contributions) {
-    const ordered = byPrecedence(contributions);
-    if (ordered.length === 0)
-        return {
-            value: undefined,
-            winner: -1,
-            denied: false,
-            memberWinners: EMPTY_MEMBER_WINNERS,
-        };
-    const denials = ordered.filter((entry) => entry.contribution.value === false);
-    if (denials.length === 0) {
-        const last = ordered[ordered.length - 1];
-        return {
-            value: last.contribution.value,
-            winner: last.index,
-            denied: false,
-            memberWinners: EMPTY_MEMBER_WINNERS,
-        };
-    }
-    const operatorDenial = denials.find((entry) => isOperatorTier(entry.contribution.tier));
-    if (operatorDenial) {
-        return {
-            value: false,
-            winner: operatorDenial.index,
-            denied: true,
-            memberWinners: EMPTY_MEMBER_WINNERS,
-        };
-    }
-    // Every denial came from a shipped default or from repo content. An operator
-    // tier ranked above the FIRST such denial may lift it by saying `true`.
-    const firstDenial = denials[0];
-    const lift = ordered.find((entry) => entry.contribution.value === true &&
-        isOperatorTier(entry.contribution.tier) &&
-        tierPrecedence(entry.contribution.tier) >
-            tierPrecedence(firstDenial.contribution.tier));
-    if (lift) {
-        return {
-            value: true,
-            winner: lift.index,
-            denied: false,
-            memberWinners: EMPTY_MEMBER_WINNERS,
-        };
-    }
-    return {
-        value: false,
-        winner: firstDenial.index,
-        denied: true,
-        memberWinners: EMPTY_MEMBER_WINNERS,
-    };
-}
-/**
- * Resolve an `array-union` deny: the union of every tier's members.
- *
- * Members keep first-contribution order, lowest precedence first, so the
- * resolved list reads oldest-authority-first and is stable across runs.
- * Duplicates are folded by their JSON encoding, which is exact for the
- * primitives a deny list holds and conservative (keeps both) for anything else.
- *
- * The winner is the FIRST tier that contributed a surviving member: the tier
- * that answers "why can I not turn this back on".
- */
-export function resolveArrayDeny(contributions) {
-    const ordered = byPrecedence(contributions);
-    const seen = new Set();
-    const members = [];
-    // Positionally parallel to `members`: the contribution that introduced each
-    // surviving member, which is the per-member answer to "who denied this"
-    // (#2427 review round 2, F2).
-    const memberWinners = [];
-    let winner = -1;
-    for (const entry of ordered) {
-        const value = entry.contribution.value;
-        if (!Array.isArray(value))
-            continue;
-        for (const member of value) {
-            const identity = primitiveIdentity(member);
-            if (identity !== undefined) {
-                if (seen.has(identity))
-                    continue;
-                seen.add(identity);
-            }
-            members.push(member);
-            memberWinners.push(entry.index);
-            if (winner === -1)
-                winner = entry.index;
-        }
-    }
-    if (winner === -1) {
-        // Nothing denied. Still report the array so a consumer sees an empty list
-        // rather than an absent field, and attribute it to the last contributor.
-        const last = ordered[ordered.length - 1];
-        return {
-            value: members,
-            winner: last ? last.index : -1,
-            denied: false,
-            memberWinners,
-        };
-    }
-    return { value: members, winner, denied: members.length > 0, memberWinners };
-}
-/**
- * A fold key for a primitive member, or `undefined` for anything else.
- *
- * Only primitives are de-duplicated. Two structurally equal objects can carry
- * different meaning, and keeping both is the conservative half of a deny list —
- * a union that dropped one would be un-denying something.
- */
-function primitiveIdentity(member) {
-    if (typeof member === "string")
-        return `s:${member}`;
-    if (typeof member === "number" || typeof member === "boolean") {
-        return `p:${String(member)}`;
-    }
-    if (member === null)
-        return "null";
-    return undefined;
-}