@ryanstark24/sfgraph-core 1.4.0 → 1.6.0

package/dist/analyze/test-coverage.d.ts

@@ -1,4 +1,52 @@
 import type { OrgId, QualifiedName } from "@ryanstark24/sfgraph-shared";
+import type { NodeFact } from "../domain/index.js";
 import type { GraphStore } from "../storage/interfaces.js";
+/**
+ * Labels a test class can exercise: `IS_TEST_FOR` only ever targets Apex
+ * classes, and an ApexTrigger is exercised through DML from tests. Every
+ * other label (LWC, Aura, Flow, FlowVersion, ...) can never be "covered", so
+ * it is reported as not applicable rather than as a gap.
+ */
+export declare const COVERAGE_LABELS: ReadonlySet<string>;
+/**
+ * True when a test class targets `qname`'s component with IS_TEST_FOR. The
+ * edge only targets classes, so a method is resolved to its owning class
+ * first (containment.ts `componentOf`).
+ */
 export declare function hasTestCoverage(store: GraphStore, orgId: OrgId, qname: QualifiedName): boolean;
+/** Coverage verdict for one qname, decided on its component (`unit`). */
+export interface CoverageVerdict {
+    /** The component coverage is decided on (a method's class, a FlowVersion's Flow). */
+    unit: string;
+    /** Label of `unit` (node label, else the qname prefix). */
+    label: string;
+    /** `label` is in COVERAGE_LABELS. */
+    applicable: boolean;
+    /** `unit` is test code: an `@isTest` class, a class with a test member
+     *  (TestMethod / `isTest`), or a class with IS_TEST_FOR out-edges. A test
+     *  method's own node carries no IS_TEST_FOR, so the class decides, and a
+     *  class and its members always get the same verdict. */
+    isTest: boolean;
+    /** A test class targets `unit` with IS_TEST_FOR. */
+    covered: boolean;
+}
+/**
+ * Facts from a local (not yet ingested) parse, consulted before the graph:
+ * wip tools see added classes, methods and tests the graph does not hold.
+ */
+export interface LocalCoverageFacts {
+    nodes?: ReadonlyMap<string, NodeFact>;
+    /** member qname -> owner qname (local CONTAINS_METHOD edges). */
+    owners?: ReadonlyMap<string, string>;
+    /** Lower-cased IS_TEST_FOR targets of local test classes. */
+    testTargets?: ReadonlySet<string>;
+    /** Lower-cased sources of local IS_TEST_FOR edges. */
+    testSources?: ReadonlySet<string>;
+}
+/**
+ * A memoised classifier: qname -> its coverage verdict. Used by
+ * test_gap_intelligence_from_git_diff, what_broke and wip_test_gap so the
+ * three agree on roll-up, test-ness and applicability.
+ */
+export declare function makeCoverageClassifier(store: GraphStore, orgId: OrgId, local?: LocalCoverageFacts): (qname: string) => CoverageVerdict;
 //# sourceMappingURL=test-coverage.d.ts.map

package/dist/analyze/test-coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-coverage.d.ts","sourceRoot":"","sources":["../../src/analyze/test-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAExE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAE9F"}
+{"version":3,"file":"test-coverage.d.ts","sourceRoot":"","sources":["../../src/analyze/test-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAExE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAI3D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAAyC,CAAC;AAE1F;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAI9F;AAED,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,qFAAqF;IACrF,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,UAAU,EAAE,OAAO,CAAC;IACpB;;;6DAGyD;IACzD,MAAM,EAAE,OAAO,CAAC;IAChB,oDAAoD;IACpD,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACtC,iEAAiE;IACjE,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,6DAA6D;IAC7D,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,sDAAsD;IACtD,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACnC;AAOD;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,KAAK,EACZ,KAAK,GAAE,kBAAuB,GAC7B,CAAC,KAAK,EAAE,MAAM,KAAK,eAAe,CAgDpC"}

package/dist/analyze/test-coverage.js

@@ -1,5 +1,76 @@
+import { asQualifiedName } from "@ryanstark24/sfgraph-shared";
 import { REL_TYPES } from "../domain/rel-types.js";
+import { componentOf, listMembers } from "./containment.js";
+import { labelOfQname } from "./edge-filters.js";
+/**
+ * Labels a test class can exercise: `IS_TEST_FOR` only ever targets Apex
+ * classes, and an ApexTrigger is exercised through DML from tests. Every
+ * other label (LWC, Aura, Flow, FlowVersion, ...) can never be "covered", so
+ * it is reported as not applicable rather than as a gap.
+ */
+export const COVERAGE_LABELS = new Set(["ApexClass", "ApexTrigger"]);
+/**
+ * True when a test class targets `qname`'s component with IS_TEST_FOR. The
+ * edge only targets classes, so a method is resolved to its owning class
+ * first (containment.ts `componentOf`).
+ */
 export function hasTestCoverage(store, orgId, qname) {
-    return store.listEdgesTo(orgId, qname, REL_TYPES.IS_TEST_FOR).length > 0;
+    const unit = componentOf(store, orgId, qname);
+    if (store.listEdgesTo(orgId, unit, REL_TYPES.IS_TEST_FOR).length > 0)
+        return true;
+    return unit !== qname && store.listEdgesTo(orgId, qname, REL_TYPES.IS_TEST_FOR).length > 0;
+}
+const flaggedTest = (n) => n != null &&
+    (n.label === "TestMethod" ||
+        n.attributes?.isTest === true);
+/**
+ * A memoised classifier: qname -> its coverage verdict. Used by
+ * test_gap_intelligence_from_git_diff, what_broke and wip_test_gap so the
+ * three agree on roll-up, test-ness and applicability.
+ */
+export function makeCoverageClassifier(store, orgId, local = {}) {
+    // Verdicts are per unit (lower-cased), so a class and each of its
+    // members get the same answer whichever is asked first.
+    const unitMemo = new Map();
+    const unitOf = new Map();
+    const nodeOf = (q) => local.nodes?.get(q) ?? store.getNode(orgId, asQualifiedName(q));
+    const localMembers = (lowerUnit) => [...(local.owners ?? [])].filter(([, o]) => o.toLowerCase() === lowerUnit).map(([m]) => m);
+    const verdictFor = (unit) => {
+        const lowerUnit = unit.toLowerCase();
+        const hit = unitMemo.get(lowerUnit);
+        if (hit)
+            return hit;
+        const unitNode = nodeOf(unit);
+        const unitQ = asQualifiedName(unit);
+        const label = unitNode?.label ?? labelOfQname(unit);
+        // Test-ness folds in the members' flags: a test method marks its class.
+        const members = [...listMembers(store, orgId, unitQ).map(String), ...localMembers(lowerUnit)];
+        const isTest = flaggedTest(unitNode) ||
+            members.some((m) => flaggedTest(nodeOf(m))) ||
+            local.testSources?.has(lowerUnit) === true ||
+            store.listEdgesFrom(orgId, unitQ, REL_TYPES.IS_TEST_FOR).length > 0;
+        const covered = local.testTargets?.has(lowerUnit) === true || hasTestCoverage(store, orgId, unitQ);
+        const v = {
+            unit,
+            label,
+            applicable: COVERAGE_LABELS.has(label),
+            isTest,
+            covered,
+        };
+        unitMemo.set(lowerUnit, v);
+        return v;
+    };
+    return (qname) => {
+        let unit = unitOf.get(qname);
+        if (unit === undefined) {
+            const rawUnit = local.owners?.get(qname) ?? String(componentOf(store, orgId, asQualifiedName(qname)));
+            // The stored spelling: qname lookups ignore case, listings should not
+            // hold one component twice.
+            const unitNode = nodeOf(rawUnit);
+            unit = unitNode ? String(unitNode.qualifiedName) : rawUnit;
+            unitOf.set(qname, unit);
+        }
+        return verdictFor(unit);
+    };
 }
 //# sourceMappingURL=test-coverage.js.map

package/dist/analyze/test-coverage.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-coverage.js","sourceRoot":"","sources":["../../src/analyze/test-coverage.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,MAAM,UAAU,eAAe,CAAC,KAAiB,EAAE,KAAY,EAAE,KAAoB;IACnF,OAAO,KAAK,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;AAC3E,CAAC"}
+{"version":3,"file":"test-coverage.js","sourceRoot":"","sources":["../../src/analyze/test-coverage.ts"],"names":[],"mappings":"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"}

package/dist/analyze/wip-changed-files.d.ts

@@ -0,0 +1,88 @@
+import type { Logger } from "@ryanstark24/sfgraph-shared";
+import type { MemberRef } from "../extractors/interfaces/metadata-source.js";
+/** Absolute paths under `root` that differ from HEAD; null when `root` is not
+ *  inside a git work tree, or when git cannot be run safely there. */
+export declare function gitChangedFiles(root: string, logger?: Logger): Set<string> | null;
+/** Files under `dirs` modified after `sinceMs`. */
+export declare function filesModifiedSince(dirs: string[], sinceMs: number): Set<string>;
+/** Changed files by every available signal; null when no signal is available. */
+export declare function localChangedFiles(opts: {
+    projectRoot: string;
+    /** Directories the metadata source walks (package dirs, DataPacks). */
+    sourceDirs: string[];
+    lastSyncedAt: number | null | undefined;
+    logger?: Logger;
+}): Set<string> | null;
+/** Filesystem path of a member's `file://` sourceUri. */
+export declare function memberPath(ref: Pick<MemberRef, "sourceUri">): string;
+/** Changed files plus every folder that contains one. */
+export interface ChangeIndex {
+    files: ReadonlySet<string>;
+    dirs: ReadonlySet<string>;
+}
+export declare function indexChanges(changed: ReadonlySet<string>): ChangeIndex;
+/**
+ * Streaming pre-check of one member against the changes, without the other
+ * members: `direct` = it owns a changed file by itself (own file, sidecar,
+ * a file under a directory member); `maybe` = a changed file sits in a folder
+ * it anchors, so ownership depends on whether it is the sole member there
+ * (`membersOwningFiles` decides with every ref); `no` = it cannot own one.
+ */
+export declare function classifyMember(ref: Pick<MemberRef, "sourceUri" | "memberName">, idx: ChangeIndex): "direct" | "maybe" | "no";
+/**
+ * Which members own the changed files. A member owns:
+ *  - its source path (a file, or every file under it when it is a directory);
+ *  - the sidecar of a file member (`Foo.cls` -> `Foo.cls-meta.xml`);
+ *  - every other file in its folder when it is the only member there (a
+ *    DataPack folder, an object folder with `fields/`, ...). A folder shared
+ *    by several members (`classes/`) gives an unowned file to nobody.
+ * Returns the indexes of owning members in `refs`. Cost is O(refs + changed
+ * x path depth).
+ */
+export declare function membersOwningFiles(refs: ReadonlyArray<Pick<MemberRef, "sourceUri" | "memberName">>, changed: ReadonlySet<string>, 
+/** Anchors of members not in `refs`, counted per folder (`selectOwningMembers`). */
+extraAnchors?: ReadonlyMap<string, number>): Set<number>;
+/** What {@link selectOwningMembers} needs of an index entry and of its loaded member. */
+export interface SelectableEntry {
+    /** The member's sourceUri. */
+    key: string;
+}
+export interface SelectableMember {
+    ref: Pick<MemberRef, "sourceUri" | "memberName">;
+}
+export interface OwnerSelection<M> {
+    /** Members that own a changed file by themselves, in index order. */
+    direct: M[];
+    /** Members that own a changed file via a sole-member folder, in `membersOwningFiles` order. */
+    owners: M[];
+    indexed: number;
+    loaded: number;
+    /** Paths of loaded members whose load() returned null (unreadable). */
+    dropped: ReadonlySet<string>;
+}
+/**
+ * The members owning `changed` files, as `membersOwningFiles` over every
+ * indexed member would find them, while `load()`ing only the members that can
+ * matter, decided from each key (path) with set lookups and a stat at most:
+ *  - direct: its path or sidecar is a changed file, or it is a folder holding
+ *    one. Loaded; owns it.
+ *  - sole: the only member whose own folder (its path for a folder member, its
+ *    parent for a file) holds a changed file. Loaded; may own via that folder.
+ *  - shared: its own folder holds a changed file but other members' do too.
+ *    Not loaded: nobody owns via that folder, and its anchor there is passed
+ *    to `membersOwningFiles` as a count (`extraAnchors`).
+ *  - The one remaining role is anchoring the folder above its own when named
+ *    after it (`memberAnchors`). A member is loaded for that only when a
+ *    changed file's walk up reaches that folder before any known anchor.
+ * Other members can neither own a changed file nor change who owns one.
+ * `load` returning null (unreadable) drops the member like `iter()` does; a
+ * member never loaded still counts as an anchor of its own folder.
+ */
+export declare function selectOwningMembers<E extends SelectableEntry, M extends SelectableMember>(entries: AsyncIterable<E> | Iterable<E>, changed: ReadonlySet<string>, load: (e: E) => Promise<M | null>): Promise<OwnerSelection<M>>;
+/**
+ * Whether a deleted `file` belongs by itself to a member at `memberPaths`: its
+ * sidecar's member (`Foo.cls` for `Foo.cls-meta.xml`) or a folder member
+ * holding it (a bundle that lost one file).
+ */
+export declare function heldByMember(file: string, memberPaths: ReadonlySet<string>): boolean;
+//# sourceMappingURL=wip-changed-files.d.ts.map

package/dist/analyze/wip-changed-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wip-changed-files.d.ts","sourceRoot":"","sources":["../../src/analyze/wip-changed-files.ts"],"names":[],"mappings":"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"}

package/dist/analyze/wip-changed-files.js

@@ -0,0 +1,422 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Local-change detection for wip "changed-only" mode, so only changed members
+ * are parsed. Two signals, either one marks a file changed:
+ *  - git: the file differs from HEAD (staged, unstaged or untracked);
+ *  - mtime: the file was modified after the org's last sync.
+ * A signal that is unavailable (not a git work tree, no `lastSyncedAt`) is
+ * skipped. With neither signal there is nothing to narrow by and the caller
+ * parses every member.
+ */
+const SKIP_DIR_NAMES = new Set(["node_modules", ".git", "dist", "coverage", ".sfdx", ".sf"]);
+/**
+ * Config overrides so git never runs a command the repo configures: the
+ * project may be an untrusted clone, and its `.git/config` (or one it
+ * includes) can name a fsmonitor, hooks, an external diff or textconv, and
+ * clean/smudge/process filters that `diff HEAD` runs to re-hash a
+ * stat-dirty file. Filters cannot be disabled by pattern, so every driver
+ * defined in any config scope is blanked by name (git skips an empty
+ * command). Null when a driver name cannot be passed safely via `-c`.
+ */
+function safeGitConfig(root) {
+    const base = [
+        "-c",
+        "core.fsmonitor=false",
+        "-c",
+        "core.hooksPath=/dev/null",
+        "-c",
+        "diff.external=",
+        "-c",
+        "core.attributesFile=/dev/null",
+    ];
+    let names;
+    try {
+        names = execFileSync("git", [
+            "-C",
+            root,
+            ...base,
+            "config",
+            "--includes",
+            "--name-only",
+            "-z",
+            "--get-regexp",
+            "^filter\\..*\\.(clean|smudge|process)$",
+        ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch (e) {
+        // Exit status 1: no filter driver configured.
+        if (e.status === 1)
+            return base;
+        return null;
+    }
+    const out = [...base];
+    const drivers = new Set();
+    for (const key of splitZ(names)) {
+        const m = /^filter\.(.+)\.(clean|smudge|process)$/s.exec(key.trim());
+        if (!m)
+            return null;
+        drivers.add(m[1]);
+    }
+    for (const d of drivers) {
+        if (/[=\n\0]/.test(d))
+            return null;
+        for (const k of ["clean", "smudge", "process"])
+            out.push("-c", `filter.${d}.${k}=`);
+        out.push("-c", `filter.${d}.required=false`);
+    }
+    return out;
+}
+function git(root, config, args) {
+    try {
+        return execFileSync("git", ["-C", root, ...config, ...args], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            maxBuffer: 256 * 1024 * 1024,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+const splitZ = (s) => s.split("\0").filter((p) => p.length > 0);
+/** Absolute paths under `root` that differ from HEAD; null when `root` is not
+ *  inside a git work tree, or when git cannot be run safely there. */
+export function gitChangedFiles(root, logger) {
+    const abs = path.resolve(root);
+    const cfg = safeGitConfig(abs);
+    if (!cfg) {
+        logger?.debug("wip: git signal skipped (repo config cannot be neutralised safely)", {
+            root: abs,
+        });
+        return null;
+    }
+    if (git(abs, cfg, ["rev-parse", "--is-inside-work-tree"])?.trim() !== "true")
+        return null;
+    // `--relative` and `ls-files` report paths relative to `root`.
+    // `--ignore-submodules`: never inspect (or run git inside) a submodule.
+    const tracked = git(abs, cfg, [
+        "diff",
+        "HEAD",
+        "--ignore-submodules",
+        "--name-only",
+        "--no-renames",
+        "--no-ext-diff",
+        "--no-textconv",
+        "--relative",
+        "-z",
+    ]) ??
+        // No HEAD yet (fresh repo): every tracked file is new.
+        git(abs, cfg, ["ls-files", "-z"]);
+    const untracked = git(abs, cfg, ["ls-files", "--others", "--exclude-standard", "-z"]);
+    if (tracked === null || untracked === null)
+        return null;
+    const out = new Set();
+    for (const rel of [...splitZ(tracked), ...splitZ(untracked)])
+        out.add(path.join(abs, rel));
+    return out;
+}
+/** Files under `dirs` modified after `sinceMs`. */
+export function filesModifiedSince(dirs, sinceMs) {
+    const out = new Set();
+    const queue = dirs.map((d) => path.resolve(d));
+    while (queue.length > 0) {
+        const dir = queue.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (!SKIP_DIR_NAMES.has(e.name))
+                    queue.push(full);
+            }
+            else if (e.isFile()) {
+                try {
+                    if (fs.statSync(full).mtimeMs > sinceMs)
+                        out.add(full);
+                }
+                catch {
+                    /* vanished mid-walk */
+                }
+            }
+        }
+    }
+    return out;
+}
+/** Changed files by every available signal; null when no signal is available. */
+export function localChangedFiles(opts) {
+    const fromGit = gitChangedFiles(opts.projectRoot, opts.logger);
+    const fromMtime = typeof opts.lastSyncedAt === "number" && opts.lastSyncedAt > 0
+        ? filesModifiedSince(opts.sourceDirs, opts.lastSyncedAt)
+        : null;
+    if (!fromGit && !fromMtime)
+        return null;
+    return new Set([...(fromGit ?? []), ...(fromMtime ?? [])]);
+}
+/** Filesystem path of a member's `file://` sourceUri. */
+export function memberPath(ref) {
+    const uri = ref.sourceUri;
+    return path.resolve(uri.startsWith("file://") ? uri.slice("file://".length) : uri);
+}
+const statIsDir = (p) => {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+/** Folders a member anchors at: a directory member at itself, a file member
+ *  at its folder, and both at the nearest ancestor (up to two levels) named
+ *  after the member (`objects/Foo/` for a stub `fields/` dir). */
+function memberAnchors(p, isDir, memberName) {
+    const own = isDir ? p : path.dirname(p);
+    const out = [own];
+    let up = own;
+    for (let k = 0; k < 2; k++) {
+        if (path.basename(up) === memberName) {
+            if (up !== own)
+                out.push(up);
+            break;
+        }
+        up = path.dirname(up);
+    }
+    return out;
+}
+export function indexChanges(changed) {
+    const files = new Set();
+    const dirs = new Set();
+    for (const raw of changed) {
+        const f = path.resolve(raw);
+        files.add(f);
+        for (let d = path.dirname(f); !dirs.has(d); d = path.dirname(d)) {
+            dirs.add(d);
+            if (path.dirname(d) === d)
+                break;
+        }
+    }
+    return { files, dirs };
+}
+/**
+ * Streaming pre-check of one member against the changes, without the other
+ * members: `direct` = it owns a changed file by itself (own file, sidecar,
+ * a file under a directory member); `maybe` = a changed file sits in a folder
+ * it anchors, so ownership depends on whether it is the sole member there
+ * (`membersOwningFiles` decides with every ref); `no` = it cannot own one.
+ */
+export function classifyMember(ref, idx) {
+    const p = memberPath(ref);
+    const isDir = statIsDir(p);
+    if (isDir ? idx.dirs.has(p) : idx.files.has(p) || idx.files.has(`${p}-meta.xml`)) {
+        return "direct";
+    }
+    return memberAnchors(p, isDir, ref.memberName).some((a) => idx.dirs.has(a)) ? "maybe" : "no";
+}
+/**
+ * Which members own the changed files. A member owns:
+ *  - its source path (a file, or every file under it when it is a directory);
+ *  - the sidecar of a file member (`Foo.cls` -> `Foo.cls-meta.xml`);
+ *  - every other file in its folder when it is the only member there (a
+ *    DataPack folder, an object folder with `fields/`, ...). A folder shared
+ *    by several members (`classes/`) gives an unowned file to nobody.
+ * Returns the indexes of owning members in `refs`. Cost is O(refs + changed
+ * x path depth).
+ */
+export function membersOwningFiles(refs, changed, 
+/** Anchors of members not in `refs`, counted per folder (`selectOwningMembers`). */
+extraAnchors) {
+    const out = new Set();
+    if (changed.size === 0)
+        return out;
+    const paths = refs.map(memberPath);
+    const isDir = paths.map(statIsDir);
+    const anchored = new Map();
+    const dirMembers = new Map();
+    const byPath = new Map();
+    const push = (m, k, i) => {
+        const list = m.get(k) ?? [];
+        if (!list.includes(i))
+            list.push(i);
+        m.set(k, list);
+    };
+    paths.forEach((p, i) => {
+        for (const a of memberAnchors(p, isDir[i] === true, refs[i]?.memberName))
+            push(anchored, a, i);
+        if (isDir[i])
+            push(dirMembers, p, i);
+        else
+            byPath.set(p, i);
+    });
+    for (const raw of changed) {
+        const f = path.resolve(raw);
+        // Own file or its sidecar (`<file>-meta.xml`).
+        const direct = byPath.get(f) ?? byPath.get(f.replace(/-meta\.xml$/, ""));
+        if (direct !== undefined) {
+            out.add(direct);
+            continue;
+        }
+        // Directory members containing the file (every ancestor folder).
+        let hit = false;
+        for (let dir = path.dirname(f);; dir = path.dirname(dir)) {
+            for (const i of dirMembers.get(dir) ?? []) {
+                out.add(i);
+                hit = true;
+            }
+            if (path.dirname(dir) === dir)
+                break;
+        }
+        if (hit)
+            continue;
+        // Nearest anchoring folder; only a sole member there owns the file.
+        for (let dir = path.dirname(f);; dir = path.dirname(dir)) {
+            const list = anchored.get(dir);
+            const extra = extraAnchors?.get(dir) ?? 0;
+            if (list || extra > 0) {
+                if (list?.length === 1 && extra === 0)
+                    out.add(list[0]);
+                break;
+            }
+            if (path.dirname(dir) === dir)
+                break;
+        }
+    }
+    return out;
+}
+/**
+ * The members owning `changed` files, as `membersOwningFiles` over every
+ * indexed member would find them, while `load()`ing only the members that can
+ * matter, decided from each key (path) with set lookups and a stat at most:
+ *  - direct: its path or sidecar is a changed file, or it is a folder holding
+ *    one. Loaded; owns it.
+ *  - sole: the only member whose own folder (its path for a folder member, its
+ *    parent for a file) holds a changed file. Loaded; may own via that folder.
+ *  - shared: its own folder holds a changed file but other members' do too.
+ *    Not loaded: nobody owns via that folder, and its anchor there is passed
+ *    to `membersOwningFiles` as a count (`extraAnchors`).
+ *  - The one remaining role is anchoring the folder above its own when named
+ *    after it (`memberAnchors`). A member is loaded for that only when a
+ *    changed file's walk up reaches that folder before any known anchor.
+ * Other members can neither own a changed file nor change who owns one.
+ * `load` returning null (unreadable) drops the member like `iter()` does; a
+ * member never loaded still counts as an anchor of its own folder.
+ */
+export async function selectOwningMembers(entries, changed, load) {
+    const idx = indexChanges(changed);
+    const infos = [];
+    const dropped = new Set();
+    const ownCount = new Map();
+    for await (const e of entries) {
+        const p = memberPath({ sourceUri: e.key });
+        const parent = path.dirname(p);
+        let direct = false;
+        let own = null;
+        let up = path.dirname(parent);
+        if (idx.dirs.has(p)) {
+            direct = true;
+            own = p;
+            up = parent;
+        }
+        else if (idx.files.has(p) || idx.files.has(`${p}-meta.xml`)) {
+            direct = true;
+            if (statIsDir(p))
+                up = parent;
+            else
+                own = idx.dirs.has(parent) ? parent : null;
+        }
+        else if (idx.dirs.has(parent)) {
+            // A folder member here holds no change (own folder = itself).
+            if (statIsDir(p))
+                up = parent;
+            else
+                own = parent;
+        }
+        // Else: own folder (parent, or p for a folder) holds no change, and a
+        // folder member's upper anchor (parent) holds none either; treating it
+        // as a file only widens `up`, a superset.
+        if (own)
+            ownCount.set(own, (ownCount.get(own) ?? 0) + 1);
+        infos.push({ e, p, direct, own, up, loaded: false });
+    }
+    const refs = [];
+    const direct = [];
+    const pending = new Map();
+    const take = async (info) => {
+        info.loaded = true;
+        const m = await load(info.e);
+        if (!m) {
+            dropped.add(info.p);
+            return;
+        }
+        const i = refs.push(m) - 1;
+        const kind = classifyMember(m.ref, idx);
+        if (kind === "direct")
+            direct.push(m);
+        else if (kind === "maybe")
+            pending.set(i, m);
+    };
+    for (const info of infos) {
+        if (info.direct || (info.own !== null && ownCount.get(info.own) === 1))
+            await take(info);
+    }
+    // Folders a changed file's walk up passes before (and including) the
+    // first folder known to be anchored.
+    const anchoredDirs = new Set(ownCount.keys());
+    for (const m of refs) {
+        const p = memberPath(m.ref);
+        for (const a of memberAnchors(p, statIsDir(p), m.ref.memberName))
+            anchoredDirs.add(a);
+    }
+    const open = new Set();
+    for (const raw of changed) {
+        for (let dir = path.dirname(path.resolve(raw));; dir = path.dirname(dir)) {
+            open.add(dir);
+            if (anchoredDirs.has(dir) || path.dirname(dir) === dir)
+                break;
+        }
+    }
+    for (const info of infos) {
+        if (!info.loaded && idx.dirs.has(info.up) && open.has(info.up))
+            await take(info);
+    }
+    const extra = new Map();
+    for (const info of infos) {
+        if (!info.loaded && info.own)
+            extra.set(info.own, (extra.get(info.own) ?? 0) + 1);
+    }
+    const owners = [];
+    for (const i of membersOwningFiles(refs.map((m) => m.ref), changed, extra)) {
+        const m = pending.get(i);
+        if (m)
+            owners.push(m);
+    }
+    return {
+        direct,
+        owners,
+        indexed: infos.length,
+        loaded: infos.filter((i) => i.loaded).length,
+        dropped,
+    };
+}
+/**
+ * Whether a deleted `file` belongs by itself to a member at `memberPaths`: its
+ * sidecar's member (`Foo.cls` for `Foo.cls-meta.xml`) or a folder member
+ * holding it (a bundle that lost one file).
+ */
+export function heldByMember(file, memberPaths) {
+    const f = path.resolve(file);
+    if (memberPaths.has(f) || memberPaths.has(f.replace(/-meta\.xml$/, "")))
+        return true;
+    for (let dir = path.dirname(f);; dir = path.dirname(dir)) {
+        if (memberPaths.has(dir))
+            return true;
+        if (path.dirname(dir) === dir)
+            return false;
+    }
+}
+//# sourceMappingURL=wip-changed-files.js.map