@variance-authority/core 0.14.0 → 0.17.1

package/dist/relate/carried.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The one walk against the arrows: what a change carries from the files it
+ * started in to every file that loads one of them, and on.
+ *
+ * Every question about what a change reached is this walk with a different
+ * step. A plain closure carries the whole file everywhere. A narrowed one
+ * carries the exports that moved, and an importer that binds none of them is
+ * not entered. Selection carries names to a reader and stops behind the
+ * importer the record answers. The walk is the same each time — a worklist of
+ * facts `(file, name)`, each fact entered once — so it is written once, here,
+ * and each caller says only what one importer does with what reached it.
+ * Handed the forward adjacency instead, the same walk runs along the arrows,
+ * which is how `dependenciesOf` closes over what a file loads. One plain
+ * closure is written again: `Graph::search` in sense's native journey graph,
+ * because Rust cannot call this.
+ *
+ * ## What is carried
+ *
+ * A {@link Carry} is either {@link WHOLE} — the file moved as it loads, or
+ * nobody can say which of its names did — or a map from the names that moved
+ * to whatever the caller carries with each. An empty map is nothing, and
+ * nothing arrives nowhere: the importer is not entered.
+ *
+ * ## The kernel owns
+ *
+ * - **the worklist** — first in, first out, so a node is first entered from a
+ *   node on a shortest path and the trail through `via` is a shortest one;
+ * - **what was entered** — the names each node holds only grow, a name is
+ *   handed to a node once, and a node that holds the whole file takes nothing
+ *   more. A name is held as a string, whichever file it arrived from: a caller
+ *   that needs two files' `default` apart names them apart. The walk ends,
+ *   whatever the steps return, after at most one entry per node and name, and
+ *   one more when a node turns whole;
+ * - **cycles** — a cycle, a self-import included, is a revisit like any other;
+ * - **the step that cannot answer** — `undefined` from a step is
+ *   {@link WHOLE}. A narrower walk has to be earned by an answer, so an
+ *   unknown can only cost a wider one.
+ */
+import { type Adjacency, type EdgeKind, type NodeId } from './graph.js';
+/** The whole file: every name it exposes, and what it does as it loads. */
+export declare const WHOLE: unique symbol;
+export type Whole = typeof WHOLE;
+/** What reaches a node: the whole file, or the names that moved, each with the caller's payload. */
+export type Carry<T> = ReadonlyMap<string, T> | Whole;
+/** Nothing: the importer is not entered, and nothing is handed on from it. */
+export declare const NOTHING: Carry<never>;
+/** What a node holds so far: the whole file, or the names handed to it. Live — read it, never keep it. */
+export type Held = ReadonlySet<string> | Whole;
+/**
+ * What one importer does with what reached it. A step left out passes what it
+ * was given on unchanged.
+ */
+export interface CarriedStep<T> {
+    /**
+     * What crosses one edge: `carried` left `from`, and `importer` loads `from`
+     * through an edge of `kind` (an index into `EDGE_KINDS`). `held` is
+     * everything `from` holds when it is expanded, which `carried` is part of:
+     * the whole file when `carried` is, and a seed's starting names even when
+     * `seedsHold` is `false`.
+     * {@link NOTHING} keeps the edge from entering `importer`; `undefined` is
+     * the whole file. Not asked of an edge into a node that already holds the
+     * whole file, since nothing it returns could add to it.
+     */
+    arrive?(importer: NodeId, from: NodeId, kind: number, carried: Carry<T>, held: Held): Carry<T> | undefined;
+    /**
+     * What `importer` hands on, given what arrived that it did not already hold
+     * — never empty. Asked once per new arrival, as the walk expands it, in the
+     * order the walk reached them, and never of a seed as it starts. Every
+     * arrival is asked, so a step that answers {@link NOTHING} for one importer
+     * still sees each arrival that reached it. {@link NOTHING} stops the walk
+     * behind it; `undefined` hands on the whole file.
+     */
+    hand?(importer: NodeId, arrived: Carry<T>): Carry<T> | undefined;
+}
+export interface CarriedOptions {
+    /** Edge kinds to walk. Every kind when absent; `RUNTIME_EDGES` for what a run loads. */
+    readonly through?: Iterable<EdgeKind>;
+    /** Nodes the walk never enters, seeds included. */
+    readonly avoid?: Iterable<NodeId>;
+    /**
+     * Marks to write into instead of a fresh array; `1` where a node was entered.
+     * A node already marked when the walk starts counts as holding the whole
+     * file, so it is neither entered nor handed anything.
+     */
+    readonly mask?: Uint8Array;
+    /**
+     * Where to record the node each one was first entered from. Not recorded
+     * when absent. A seed's entry is left as it was, `-1` by convention.
+     */
+    readonly via?: Int32Array;
+    /**
+     * Whether a seed holds what it starts with. When `false` it holds nothing,
+     * so what a cycle carries back to it is new, and handed to it: a file can
+     * read its own names back through an importer.
+     */
+    readonly seedsHold?: boolean;
+}
+export interface Reached {
+    /** `1` where a node was entered, including the seeds. */
+    readonly mask: Uint8Array;
+    /** The entered nodes, in the order they were first entered. */
+    readonly entered: readonly NodeId[];
+}
+/**
+ * Walk `edges` from `seeds`, each with what its change carries, and hand each
+ * node it enters what reaches it through `step`. `edges` is the reverse
+ * adjacency for what a change reaches, the forward one for what a file loads.
+ * A seed listed more than once starts with everything its listings carry.
+ */
+export declare function carried<T>(edges: Adjacency, seeds: Iterable<readonly [NodeId, Carry<T>]>, step?: CarriedStep<T>, options?: CarriedOptions): Reached;
+/**
+ * The marked nodes in id order. The walk's own order depends on seed order;
+ * this one does not, so a report built from it is byte-stable whatever order
+ * the caller listed its changed files in.
+ */
+export declare function inIdOrder(mask: Uint8Array): NodeId[];
+/**
+ * A kind filter as a byte lookup, so the inner loop tests a byte; `fallback`
+ * when no kinds are named.
+ */
+export declare function allowedKinds(through: Iterable<EdgeKind> | undefined, fallback?: readonly EdgeKind[]): Uint8Array;
+//# sourceMappingURL=carried.d.ts.map

package/dist/relate/carried.js

@@ -0,0 +1,279 @@
+// compass: variance-authority.reach.relations
+/**
+ * The one walk against the arrows: what a change carries from the files it
+ * started in to every file that loads one of them, and on.
+ *
+ * Every question about what a change reached is this walk with a different
+ * step. A plain closure carries the whole file everywhere. A narrowed one
+ * carries the exports that moved, and an importer that binds none of them is
+ * not entered. Selection carries names to a reader and stops behind the
+ * importer the record answers. The walk is the same each time — a worklist of
+ * facts `(file, name)`, each fact entered once — so it is written once, here,
+ * and each caller says only what one importer does with what reached it.
+ * Handed the forward adjacency instead, the same walk runs along the arrows,
+ * which is how `dependenciesOf` closes over what a file loads. One plain
+ * closure is written again: `Graph::search` in sense's native journey graph,
+ * because Rust cannot call this.
+ *
+ * ## What is carried
+ *
+ * A {@link Carry} is either {@link WHOLE} — the file moved as it loads, or
+ * nobody can say which of its names did — or a map from the names that moved
+ * to whatever the caller carries with each. An empty map is nothing, and
+ * nothing arrives nowhere: the importer is not entered.
+ *
+ * ## The kernel owns
+ *
+ * - **the worklist** — first in, first out, so a node is first entered from a
+ *   node on a shortest path and the trail through `via` is a shortest one;
+ * - **what was entered** — the names each node holds only grow, a name is
+ *   handed to a node once, and a node that holds the whole file takes nothing
+ *   more. A name is held as a string, whichever file it arrived from: a caller
+ *   that needs two files' `default` apart names them apart. The walk ends,
+ *   whatever the steps return, after at most one entry per node and name, and
+ *   one more when a node turns whole;
+ * - **cycles** — a cycle, a self-import included, is a revisit like any other;
+ * - **the step that cannot answer** — `undefined` from a step is
+ *   {@link WHOLE}. A narrower walk has to be earned by an answer, so an
+ *   unknown can only cost a wider one.
+ */
+import { EDGE_KINDS } from './graph.js';
+/** The whole file: every name it exposes, and what it does as it loads. */
+export const WHOLE = Symbol('whole');
+/** Nothing: the importer is not entered, and nothing is handed on from it. */
+export const NOTHING = new Map();
+/**
+ * Walk `edges` from `seeds`, each with what its change carries, and hand each
+ * node it enters what reaches it through `step`. `edges` is the reverse
+ * adjacency for what a change reaches, the forward one for what a file loads.
+ * A seed listed more than once starts with everything its listings carry.
+ */
+export function carried(edges, seeds, step = {}, options = {}) {
+    const { offset, target, kind } = edges;
+    const nodes = offset.length - 1;
+    const mask = options.mask ?? new Uint8Array(nodes);
+    const { via } = options;
+    const allowed = options.through === undefined ? EVERY : allowedKinds(options.through);
+    let avoided;
+    if (options.avoid !== undefined) {
+        // A typed array ignores a write out of its range, so an id the graph does
+        // not hold avoids nothing.
+        for (const id of options.avoid) {
+            avoided ??= new Uint8Array(nodes);
+            avoided[id] = 1;
+        }
+    }
+    // An entered node absent here holds the whole file.
+    let partial;
+    // The worklist, one number an entry: the node itself when it carries the
+    // whole file, `~k` when it carries names, held at `k` aside. Each entry is
+    // what arrived, and is handed on as it is expanded: the same entries in the
+    // same order as asking on arrival, with the edge loop left free of the step.
+    // While every entry is a node's first, the worklist is the list of entered
+    // nodes too, so a walk pushes one number a node and nothing else. The first
+    // entry that is not a node's first sets `entered` apart, and from then on it
+    // is kept on its own.
+    const queued = [];
+    let aside;
+    let entered;
+    const { arrive, hand } = step;
+    const holdsNothing = options.seedsHold === false;
+    for (const [seed, carry] of seeds) {
+        if (seed < 0 || seed >= nodes || avoided?.[seed] === 1)
+            continue;
+        let start = carry;
+        if (mask[seed] !== 1) {
+            mask[seed] = 1;
+            entered?.push(seed);
+            if (holdsNothing)
+                (partial ??= new Map()).set(seed, new Set());
+            else if (carry !== WHOLE)
+                (partial ??= new Map()).set(seed, namesOf(carry));
+        }
+        else {
+            // Marked before the walk, which holds the whole file, or listed again.
+            const holds = partial?.get(seed);
+            if (holds === undefined)
+                continue;
+            // A seed that holds nothing of what it starts with starts every listing.
+            if (!holdsNothing) {
+                if (carry === WHOLE)
+                    partial.delete(seed);
+                else
+                    start = addedTo(holds, carry);
+            }
+            if (start !== WHOLE && start.size === 0)
+                continue;
+            entered ??= nodesOf(queued, aside, []);
+        }
+        queued.push(start === WHOLE ? seed : named((aside ??= { nodes: [], carries: [] }), seed, start));
+    }
+    const starts = queued.length;
+    // With no step on the edge and every seed whole, nothing is held by name
+    // until a hand answers with names, and the walk runs in a loop of its own
+    // until then: a closure and a cut walk are this loop, unslowed by the walks
+    // that narrow.
+    let from = 0;
+    let handed;
+    if (arrive === undefined && partial === undefined && aside === undefined) {
+        const stop = wholeFrom(edges, queued, starts, step, mask, via, allowed, avoided);
+        if (stop === undefined)
+            return { mask, entered: queued };
+        ({ head: from, carry: handed } = stop);
+    }
+    for (let head = from; head < queued.length; head += 1) {
+        const entry = queued[head];
+        const node = entry >= 0 ? entry : aside.nodes[~entry];
+        let carry = entry >= 0 ? WHOLE : aside.carries[~entry];
+        if (handed !== undefined && head === from)
+            carry = handed;
+        else if (hand !== undefined && head >= starts)
+            carry = step.hand(node, carry) ?? WHOLE;
+        if (carry !== WHOLE && carry.size === 0)
+            continue;
+        // What it holds, which what it carries is part of: a seed that holds
+        // nothing of what it starts with still starts with it.
+        const holds = carry === WHOLE ? undefined : partial?.get(node);
+        let held = holds ?? WHOLE;
+        if (holdsNothing && head < starts && holds !== undefined && carry !== WHOLE) {
+            const both = namesOf(carry);
+            for (const name of holds)
+                both.add(name);
+            held = both;
+        }
+        const end = offset[node + 1];
+        for (let edge = offset[node]; edge < end; edge += 1) {
+            const edgeKind = kind[edge];
+            if (allowed[edgeKind] !== 1)
+                continue;
+            const next = target[edge];
+            if (avoided?.[next] === 1)
+                continue;
+            // Entered and absent from `partial`: it holds the whole file already.
+            const seen = mask[next] === 1;
+            if (seen && (partial === undefined || !partial.has(next)))
+                continue;
+            const out = arrive === undefined ? carry : (step.arrive(next, node, edgeKind, carry, held) ?? WHOLE);
+            if (out !== WHOLE && out.size === 0)
+                continue;
+            let arrived = out;
+            if (!seen) {
+                mask[next] = 1;
+                if (via !== undefined)
+                    via[next] = node;
+                entered?.push(next);
+                if (out !== WHOLE)
+                    (partial ??= new Map()).set(next, namesOf(out));
+            }
+            else {
+                if (out === WHOLE)
+                    partial.delete(next);
+                else {
+                    arrived = addedTo(partial.get(next), out);
+                    if (arrived.size === 0)
+                        continue;
+                }
+                entered ??= nodesOf(queued, aside, []);
+            }
+            queued.push(arrived === WHOLE ? next : named((aside ??= { nodes: [], carries: [] }), next, arrived));
+        }
+    }
+    // Nothing carried by name, nothing to decode: every entry is a node.
+    return { mask, entered: entered ?? (aside === undefined ? queued : nodesOf(queued, aside, queued)) };
+}
+/**
+ * The walk while every entry carries the whole file: an entered node takes
+ * nothing more, so the mask is the whole record of what was entered. Returns
+ * where a hand first answered with names, or `undefined` when the walk ended
+ * whole.
+ */
+function wholeFrom(edges, queued, starts, step, mask, via, allowed, avoided) {
+    const { offset, target, kind } = edges;
+    const asks = step.hand !== undefined;
+    for (let head = 0; head < queued.length; head += 1) {
+        const node = queued[head];
+        if (asks && head >= starts) {
+            const carry = step.hand(node, WHOLE);
+            if (carry !== undefined && carry !== WHOLE) {
+                if (carry.size === 0)
+                    continue;
+                return { head, carry };
+            }
+        }
+        const end = offset[node + 1];
+        for (let edge = offset[node]; edge < end; edge += 1) {
+            if (allowed[kind[edge]] !== 1)
+                continue;
+            const next = target[edge];
+            if (mask[next] === 1 || avoided?.[next] === 1)
+                continue;
+            mask[next] = 1;
+            if (via !== undefined)
+                via[next] = node;
+            queued.push(next);
+        }
+    }
+    return undefined;
+}
+/** The worklist entry for `node` carrying the names in `carry`. */
+function named(aside, node, carry) {
+    aside.carries.push(carry);
+    return ~(aside.nodes.push(node) - 1);
+}
+/** The nodes of `entries`, written into `into`, which may be `entries` itself. */
+function nodesOf(entries, aside, into) {
+    for (let at = 0; at < entries.length; at += 1) {
+        const entry = entries[at];
+        into[at] = entry >= 0 ? entry : aside.nodes[~entry];
+    }
+    return into;
+}
+/** What `carry` adds to `holds`, which takes it in. */
+function addedTo(holds, carry) {
+    const added = new Map();
+    for (const [name, payload] of carry) {
+        if (holds.has(name))
+            continue;
+        holds.add(name);
+        added.set(name, payload);
+    }
+    return added;
+}
+/**
+ * The names a carry holds, as a set the walk grows. Added one by one: V8 builds
+ * a `Set` from a map's key iterator several times slower than this loop.
+ */
+function namesOf(carry) {
+    const names = new Set();
+    for (const name of carry.keys())
+        names.add(name);
+    return names;
+}
+/**
+ * The marked nodes in id order. The walk's own order depends on seed order;
+ * this one does not, so a report built from it is byte-stable whatever order
+ * the caller listed its changed files in.
+ */
+export function inIdOrder(mask) {
+    const visited = [];
+    for (let id = 0; id < mask.length; id += 1)
+        if (mask[id] === 1)
+            visited.push(id);
+    return visited;
+}
+/** The default filter, built once: a walk runs once per changed file. */
+const EVERY = allowedKinds(undefined);
+/**
+ * A kind filter as a byte lookup, so the inner loop tests a byte; `fallback`
+ * when no kinds are named.
+ */
+export function allowedKinds(through, fallback = EDGE_KINDS) {
+    const allowed = new Uint8Array(EDGE_KINDS.length);
+    for (const name of through ?? fallback) {
+        const at = EDGE_KINDS.indexOf(name);
+        if (at !== -1)
+            allowed[at] = 1;
+    }
+    return allowed;
+}
+//# sourceMappingURL=carried.js.map

package/dist/relate/carried.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"carried.js","sourceRoot":"","sources":["../../src/relate/carried.ts"],"names":[],"mappings":"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","sourcesContent":["// compass: variance-authority.reach.relations\n/**\n * The one walk against the arrows: what a change carries from the files it\n * started in to every file that loads one of them, and on.\n *\n * Every question about what a change reached is this walk with a different\n * step. A plain closure carries the whole file everywhere. A narrowed one\n * carries the exports that moved, and an importer that binds none of them is\n * not entered. Selection carries names to a reader and stops behind the\n * importer the record answers. The walk is the same each time — a worklist of\n * facts `(file, name)`, each fact entered once — so it is written once, here,\n * and each caller says only what one importer does with what reached it.\n * Handed the forward adjacency instead, the same walk runs along the arrows,\n * which is how `dependenciesOf` closes over what a file loads. One plain\n * closure is written again: `Graph::search` in sense's native journey graph,\n * because Rust cannot call this.\n *\n * ## What is carried\n *\n * A {@link Carry} is either {@link WHOLE} — the file moved as it loads, or\n * nobody can say which of its names did — or a map from the names that moved\n * to whatever the caller carries with each. An empty map is nothing, and\n * nothing arrives nowhere: the importer is not entered.\n *\n * ## The kernel owns\n *\n * - **the worklist** — first in, first out, so a node is first entered from a\n *   node on a shortest path and the trail through `via` is a shortest one;\n * - **what was entered** — the names each node holds only grow, a name is\n *   handed to a node once, and a node that holds the whole file takes nothing\n *   more. A name is held as a string, whichever file it arrived from: a caller\n *   that needs two files' `default` apart names them apart. The walk ends,\n *   whatever the steps return, after at most one entry per node and name, and\n *   one more when a node turns whole;\n * - **cycles** — a cycle, a self-import included, is a revisit like any other;\n * - **the step that cannot answer** — `undefined` from a step is\n *   {@link WHOLE}. A narrower walk has to be earned by an answer, so an\n *   unknown can only cost a wider one.\n */\n\nimport { EDGE_KINDS, type Adjacency, type EdgeKind, type NodeId } from './graph.js';\n\n/** The whole file: every name it exposes, and what it does as it loads. */\nexport const WHOLE: unique symbol = Symbol('whole');\nexport type Whole = typeof WHOLE;\n\n/** What reaches a node: the whole file, or the names that moved, each with the caller's payload. */\nexport type Carry<T> = ReadonlyMap<string, T> | Whole;\n\n/** Nothing: the importer is not entered, and nothing is handed on from it. */\nexport const NOTHING: Carry<never> = new Map<string, never>();\n\n/** What a node holds so far: the whole file, or the names handed to it. Live — read it, never keep it. */\nexport type Held = ReadonlySet<string> | Whole;\n\n/**\n * What one importer does with what reached it. A step left out passes what it\n * was given on unchanged.\n */\nexport interface CarriedStep<T> {\n  /**\n   * What crosses one edge: `carried` left `from`, and `importer` loads `from`\n   * through an edge of `kind` (an index into `EDGE_KINDS`). `held` is\n   * everything `from` holds when it is expanded, which `carried` is part of:\n   * the whole file when `carried` is, and a seed's starting names even when\n   * `seedsHold` is `false`.\n   * {@link NOTHING} keeps the edge from entering `importer`; `undefined` is\n   * the whole file. Not asked of an edge into a node that already holds the\n   * whole file, since nothing it returns could add to it.\n   */\n  arrive?(importer: NodeId, from: NodeId, kind: number, carried: Carry<T>, held: Held): Carry<T> | undefined;\n  /**\n   * What `importer` hands on, given what arrived that it did not already hold\n   * — never empty. Asked once per new arrival, as the walk expands it, in the\n   * order the walk reached them, and never of a seed as it starts. Every\n   * arrival is asked, so a step that answers {@link NOTHING} for one importer\n   * still sees each arrival that reached it. {@link NOTHING} stops the walk\n   * behind it; `undefined` hands on the whole file.\n   */\n  hand?(importer: NodeId, arrived: Carry<T>): Carry<T> | undefined;\n}\n\nexport interface CarriedOptions {\n  /** Edge kinds to walk. Every kind when absent; `RUNTIME_EDGES` for what a run loads. */\n  readonly through?: Iterable<EdgeKind>;\n  /** Nodes the walk never enters, seeds included. */\n  readonly avoid?: Iterable<NodeId>;\n  /**\n   * Marks to write into instead of a fresh array; `1` where a node was entered.\n   * A node already marked when the walk starts counts as holding the whole\n   * file, so it is neither entered nor handed anything.\n   */\n  readonly mask?: Uint8Array;\n  /**\n   * Where to record the node each one was first entered from. Not recorded\n   * when absent. A seed's entry is left as it was, `-1` by convention.\n   */\n  readonly via?: Int32Array;\n  /**\n   * Whether a seed holds what it starts with. When `false` it holds nothing,\n   * so what a cycle carries back to it is new, and handed to it: a file can\n   * read its own names back through an importer.\n   */\n  readonly seedsHold?: boolean;\n}\n\nexport interface Reached {\n  /** `1` where a node was entered, including the seeds. */\n  readonly mask: Uint8Array;\n  /** The entered nodes, in the order they were first entered. */\n  readonly entered: readonly NodeId[];\n}\n\n/**\n * Walk `edges` from `seeds`, each with what its change carries, and hand each\n * node it enters what reaches it through `step`. `edges` is the reverse\n * adjacency for what a change reaches, the forward one for what a file loads.\n * A seed listed more than once starts with everything its listings carry.\n */\nexport function carried<T>(\n  edges: Adjacency,\n  seeds: Iterable<readonly [NodeId, Carry<T>]>,\n  step: CarriedStep<T> = {},\n  options: CarriedOptions = {},\n): Reached {\n  const { offset, target, kind } = edges;\n  const nodes = offset.length - 1;\n  const mask = options.mask ?? new Uint8Array(nodes);\n  const { via } = options;\n  const allowed = options.through === undefined ? EVERY : allowedKinds(options.through);\n  let avoided: Uint8Array | undefined;\n  if (options.avoid !== undefined) {\n    // A typed array ignores a write out of its range, so an id the graph does\n    // not hold avoids nothing.\n    for (const id of options.avoid) {\n      avoided ??= new Uint8Array(nodes);\n      avoided[id] = 1;\n    }\n  }\n\n  // An entered node absent here holds the whole file.\n  let partial: Map<NodeId, Set<string>> | undefined;\n  // The worklist, one number an entry: the node itself when it carries the\n  // whole file, `~k` when it carries names, held at `k` aside. Each entry is\n  // what arrived, and is handed on as it is expanded: the same entries in the\n  // same order as asking on arrival, with the edge loop left free of the step.\n  // While every entry is a node's first, the worklist is the list of entered\n  // nodes too, so a walk pushes one number a node and nothing else. The first\n  // entry that is not a node's first sets `entered` apart, and from then on it\n  // is kept on its own.\n  const queued: number[] = [];\n  let aside: Aside<T> | undefined;\n  let entered: NodeId[] | undefined;\n  const { arrive, hand } = step;\n\n  const holdsNothing = options.seedsHold === false;\n  for (const [seed, carry] of seeds) {\n    if (seed < 0 || seed >= nodes || avoided?.[seed] === 1) continue;\n    let start: Carry<T> = carry;\n    if (mask[seed] !== 1) {\n      mask[seed] = 1;\n      entered?.push(seed);\n      if (holdsNothing) (partial ??= new Map()).set(seed, new Set());\n      else if (carry !== WHOLE) (partial ??= new Map()).set(seed, namesOf(carry));\n    } else {\n      // Marked before the walk, which holds the whole file, or listed again.\n      const holds = partial?.get(seed);\n      if (holds === undefined) continue;\n      // A seed that holds nothing of what it starts with starts every listing.\n      if (!holdsNothing) {\n        if (carry === WHOLE) partial!.delete(seed);\n        else start = addedTo(holds, carry);\n      }\n      if (start !== WHOLE && start.size === 0) continue;\n      entered ??= nodesOf(queued, aside, []);\n    }\n    queued.push(start === WHOLE ? seed : named((aside ??= { nodes: [], carries: [] }), seed, start));\n  }\n  const starts = queued.length;\n\n  // With no step on the edge and every seed whole, nothing is held by name\n  // until a hand answers with names, and the walk runs in a loop of its own\n  // until then: a closure and a cut walk are this loop, unslowed by the walks\n  // that narrow.\n  let from = 0;\n  let handed: ReadonlyMap<string, T> | undefined;\n  if (arrive === undefined && partial === undefined && aside === undefined) {\n    const stop = wholeFrom(edges, queued, starts, step, mask, via, allowed, avoided);\n    if (stop === undefined) return { mask, entered: queued };\n    ({ head: from, carry: handed } = stop);\n  }\n\n  for (let head = from; head < queued.length; head += 1) {\n    const entry = queued[head]!;\n    const node = entry >= 0 ? entry : aside!.nodes[~entry]!;\n    let carry: Carry<T> = entry >= 0 ? WHOLE : aside!.carries[~entry]!;\n    if (handed !== undefined && head === from) carry = handed;\n    else if (hand !== undefined && head >= starts) carry = step.hand!(node, carry) ?? WHOLE;\n    if (carry !== WHOLE && carry.size === 0) continue;\n    // What it holds, which what it carries is part of: a seed that holds\n    // nothing of what it starts with still starts with it.\n    const holds = carry === WHOLE ? undefined : partial?.get(node);\n    let held: Held = holds ?? WHOLE;\n    if (holdsNothing && head < starts && holds !== undefined && carry !== WHOLE) {\n      const both = namesOf(carry);\n      for (const name of holds) both.add(name);\n      held = both;\n    }\n    const end = offset[node + 1]!;\n\n    for (let edge = offset[node]!; edge < end; edge += 1) {\n      const edgeKind = kind[edge]!;\n      if (allowed[edgeKind] !== 1) continue;\n      const next = target[edge]!;\n      if (avoided?.[next] === 1) continue;\n      // Entered and absent from `partial`: it holds the whole file already.\n      const seen = mask[next] === 1;\n      if (seen && (partial === undefined || !partial.has(next))) continue;\n\n      const out = arrive === undefined ? carry : (step.arrive!(next, node, edgeKind, carry, held) ?? WHOLE);\n      if (out !== WHOLE && out.size === 0) continue;\n      let arrived = out;\n      if (!seen) {\n        mask[next] = 1;\n        if (via !== undefined) via[next] = node;\n        entered?.push(next);\n        if (out !== WHOLE) (partial ??= new Map()).set(next, namesOf(out));\n      } else {\n        if (out === WHOLE) partial!.delete(next);\n        else {\n          arrived = addedTo(partial!.get(next)!, out);\n          if (arrived.size === 0) continue;\n        }\n        entered ??= nodesOf(queued, aside, []);\n      }\n      queued.push(arrived === WHOLE ? next : named((aside ??= { nodes: [], carries: [] }), next, arrived));\n    }\n  }\n\n  // Nothing carried by name, nothing to decode: every entry is a node.\n  return { mask, entered: entered ?? (aside === undefined ? queued : nodesOf(queued, aside, queued)) };\n}\n\n/** Where a whole walk met a hand that answered with names, and the names. */\ninterface Handed<T> {\n  readonly head: number;\n  readonly carry: ReadonlyMap<string, T>;\n}\n\n/**\n * The walk while every entry carries the whole file: an entered node takes\n * nothing more, so the mask is the whole record of what was entered. Returns\n * where a hand first answered with names, or `undefined` when the walk ended\n * whole.\n */\nfunction wholeFrom<T>(\n  edges: Adjacency,\n  queued: NodeId[],\n  starts: number,\n  step: CarriedStep<T>,\n  mask: Uint8Array,\n  via: Int32Array | undefined,\n  allowed: Uint8Array,\n  avoided: Uint8Array | undefined,\n): Handed<T> | undefined {\n  const { offset, target, kind } = edges;\n  const asks = step.hand !== undefined;\n  for (let head = 0; head < queued.length; head += 1) {\n    const node = queued[head]!;\n    if (asks && head >= starts) {\n      const carry = step.hand!(node, WHOLE);\n      if (carry !== undefined && carry !== WHOLE) {\n        if (carry.size === 0) continue;\n        return { head, carry };\n      }\n    }\n    const end = offset[node + 1]!;\n    for (let edge = offset[node]!; edge < end; edge += 1) {\n      if (allowed[kind[edge]!] !== 1) continue;\n      const next = target[edge]!;\n      if (mask[next] === 1 || avoided?.[next] === 1) continue;\n      mask[next] = 1;\n      if (via !== undefined) via[next] = node;\n      queued.push(next);\n    }\n  }\n  return undefined;\n}\n\n/** What the worklist carries by name, out of line so a whole entry is one number. */\ninterface Aside<T> {\n  readonly nodes: NodeId[];\n  readonly carries: Array<ReadonlyMap<string, T>>;\n}\n\n/** The worklist entry for `node` carrying the names in `carry`. */\nfunction named<T>(aside: Aside<T>, node: NodeId, carry: ReadonlyMap<string, T>): number {\n  aside.carries.push(carry);\n  return ~(aside.nodes.push(node) - 1);\n}\n\n/** The nodes of `entries`, written into `into`, which may be `entries` itself. */\nfunction nodesOf<T>(entries: readonly number[], aside: Aside<T> | undefined, into: NodeId[]): NodeId[] {\n  for (let at = 0; at < entries.length; at += 1) {\n    const entry = entries[at]!;\n    into[at] = entry >= 0 ? entry : aside!.nodes[~entry]!;\n  }\n  return into;\n}\n\n/** What `carry` adds to `holds`, which takes it in. */\nfunction addedTo<T>(holds: Set<string>, carry: ReadonlyMap<string, T>): ReadonlyMap<string, T> {\n  const added = new Map<string, T>();\n  for (const [name, payload] of carry) {\n    if (holds.has(name)) continue;\n    holds.add(name);\n    added.set(name, payload);\n  }\n  return added;\n}\n\n/**\n * The names a carry holds, as a set the walk grows. Added one by one: V8 builds\n * a `Set` from a map's key iterator several times slower than this loop.\n */\nfunction namesOf<T>(carry: ReadonlyMap<string, T>): Set<string> {\n  const names = new Set<string>();\n  for (const name of carry.keys()) names.add(name);\n  return names;\n}\n\n/**\n * The marked nodes in id order. The walk's own order depends on seed order;\n * this one does not, so a report built from it is byte-stable whatever order\n * the caller listed its changed files in.\n */\nexport function inIdOrder(mask: Uint8Array): NodeId[] {\n  const visited: NodeId[] = [];\n  for (let id = 0; id < mask.length; id += 1) if (mask[id] === 1) visited.push(id);\n  return visited;\n}\n\n/** The default filter, built once: a walk runs once per changed file. */\nconst EVERY = allowedKinds(undefined);\n\n/**\n * A kind filter as a byte lookup, so the inner loop tests a byte; `fallback`\n * when no kinds are named.\n */\nexport function allowedKinds(\n  through: Iterable<EdgeKind> | undefined,\n  fallback: readonly EdgeKind[] = EDGE_KINDS,\n): Uint8Array {\n  const allowed = new Uint8Array(EDGE_KINDS.length);\n  for (const name of through ?? fallback) {\n    const at = EDGE_KINDS.indexOf(name);\n    if (at !== -1) allowed[at] = 1;\n  }\n  return allowed;\n}\n"]}

package/dist/relate/graph.d.ts

@@ -47,7 +47,7 @@
  * for each name an install resolved. That is deliberate rather than incidental. A
  * component relation — *`TodoFooter` renders `Chip`* — is another edge kind
  * between nodes of another kind in this same structure, and
- * [`composition.md`](../../../../docs/composition.md) already computes exactly
+ * [`composition.md`](https://variance-authority.dev/docs/composition) already computes exactly
  * that relation from what a run rendered. One graph means the static answer and
  * the rendered answer are joinable rather than adjacent.
  *
@@ -56,7 +56,7 @@
  * tests, and leaves it again at the packages — so a bumped dependency is a node
  * like any other, and *which of our files a new `jsdom` can affect* is the
  * one traversal this file already performs, seeded on the other side
- * ([`docs/selecting.md`](../../../../docs/selecting.md)).
+ * ([`docs/selecting.md`](https://variance-authority.dev/docs/selecting)).
  *
  * ## What it is not
  *
@@ -76,11 +76,11 @@ export type NodeKind = (typeof NODE_KINDS)[number];
  * Edge kinds, in id order.
  *
  * The distinctions are kept because they explain a finding. One of them also
- * decides a walk: `type` is erased by every compiler, so nothing behind it runs
- * and nothing behind it renders, and the default traversal leaves it out
- * (`RUNTIME_EDGES`). A caller whose question is about source rather than about a
- * runtime — a docgen that reads prop types, a type-check gate — passes
- * `EDGE_KINDS` and walks it.
+ * decides a runtime walk: `type` is erased by every compiler, so nothing behind
+ * it runs and nothing behind it renders. A traversal walks every kind unless its
+ * caller names others, because a type-only import is still a dependency; a
+ * caller whose question is what a run loads — test selection — passes
+ * `RUNTIME_EDGES` and leaves it out.
  */
 export declare const EDGE_KINDS: readonly [
 /** `import x from './y'` — a value import. */
@@ -101,10 +101,11 @@ export declare const EDGE_KINDS: readonly [
 'depends'];
 export type EdgeKind = (typeof EDGE_KINDS)[number];
 /**
- * The edge kinds a runtime loads through: every kind but `type`. The
- * default for a traversal, and the list a caller widens from. A closure folds a
- * shorter list (`CLOSURE_EDGES`), because a digest is a claim about bytes and
- * one of these kinds leads nowhere any bytes are.
+ * The edge kinds a runtime loads through: every kind but `type`. What a caller
+ * asking a runtime question, such as test selection, passes as `through`; a
+ * traversal walks every kind when it is not told. A closure folds a shorter
+ * list (`CLOSURE_EDGES`), because a digest is a claim about bytes and one of
+ * these kinds leads nowhere any bytes are.
  */
 export declare const RUNTIME_EDGES: readonly EdgeKind[];
 export interface Node {
@@ -114,10 +115,11 @@ export interface Node {
      * package the name source code imports it by — `@mui/material`, never a
      * version and never a resolution. Which copy a resolver handed any one
      * importer is unanswerable without running that resolver, and the question
-     * this graph is asked never needs it ([`sense/lock`](../../../sense/src/lock/index.ts)).
+     * this graph is asked never needs it ([`sense/lock`](https://github.com/Variance-Authority/variance-authority/blob/main/packages/sense/src/lock/index.ts)).
      */
     readonly name: string;
 }
+/** One edge as a reader of a file states it: `from` reaches `to` through an edge of `kind`. */
 export interface Relation {
     readonly from: Node;
     readonly to: Node;

package/dist/relate/graph.js

@@ -47,7 +47,7 @@
  * for each name an install resolved. That is deliberate rather than incidental. A
  * component relation — *`TodoFooter` renders `Chip`* — is another edge kind
  * between nodes of another kind in this same structure, and
- * [`composition.md`](../../../../docs/composition.md) already computes exactly
+ * [`composition.md`](https://variance-authority.dev/docs/composition) already computes exactly
  * that relation from what a run rendered. One graph means the static answer and
  * the rendered answer are joinable rather than adjacent.
  *
@@ -56,7 +56,7 @@
  * tests, and leaves it again at the packages — so a bumped dependency is a node
  * like any other, and *which of our files a new `jsdom` can affect* is the
  * one traversal this file already performs, seeded on the other side
- * ([`docs/selecting.md`](../../../../docs/selecting.md)).
+ * ([`docs/selecting.md`](https://variance-authority.dev/docs/selecting)).
  *
  * ## What it is not
  *
@@ -74,11 +74,11 @@ export const NODE_KINDS = ['file', 'component', 'package'];
  * Edge kinds, in id order.
  *
  * The distinctions are kept because they explain a finding. One of them also
- * decides a walk: `type` is erased by every compiler, so nothing behind it runs
- * and nothing behind it renders, and the default traversal leaves it out
- * (`RUNTIME_EDGES`). A caller whose question is about source rather than about a
- * runtime — a docgen that reads prop types, a type-check gate — passes
- * `EDGE_KINDS` and walks it.
+ * decides a runtime walk: `type` is erased by every compiler, so nothing behind
+ * it runs and nothing behind it renders. A traversal walks every kind unless its
+ * caller names others, because a type-only import is still a dependency; a
+ * caller whose question is what a run loads — test selection — passes
+ * `RUNTIME_EDGES` and leaves it out.
  */
 export const EDGE_KINDS = [
     /** `import x from './y'` — a value import. */
@@ -99,10 +99,11 @@ export const EDGE_KINDS = [
     'depends',
 ];
 /**
- * The edge kinds a runtime loads through: every kind but `type`. The
- * default for a traversal, and the list a caller widens from. A closure folds a
- * shorter list (`CLOSURE_EDGES`), because a digest is a claim about bytes and
- * one of these kinds leads nowhere any bytes are.
+ * The edge kinds a runtime loads through: every kind but `type`. What a caller
+ * asking a runtime question, such as test selection, passes as `through`; a
+ * traversal walks every kind when it is not told. A closure folds a shorter
+ * list (`CLOSURE_EDGES`), because a digest is a claim about bytes and one of
+ * these kinds leads nowhere any bytes are.
  */
 export const RUNTIME_EDGES = EDGE_KINDS.filter((kind) => kind !== 'type');
 /**