@variance-authority/core 0.13.0 → 0.15.0

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. `RUNTIME_EDGES` when absent: every kind but `type`. */
+    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, RUNTIME_EDGES } 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 ? RUNTIME : 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: selection walks once per changed file. */
+const RUNTIME = 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 = RUNTIME_EDGES) {
+    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, RUNTIME_EDGES, 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. `RUNTIME_EDGES` when absent: every kind but `type`. */\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 ? RUNTIME : 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: selection walks once per changed file. */\nconst RUNTIME = 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[] = RUNTIME_EDGES,\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/dominate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dominance over a graph with one root.
+ *
+ * D dominates N when every path from the root to N passes through D; N's
+ * immediate dominator is the nearest such D, and the immediate dominators form
+ * a tree. Cooper, Harvey and Kennedy's iterative algorithm ("A Simple, Fast
+ * Dominance Algorithm", 2001): intersect the predecessors' dominators in
+ * reverse postorder until nothing changes. It holds on cycles, and on the graphs
+ * an import walk produces it settles in two or three passes.
+ */
+/**
+ * Each node the root reaches, mapped to its immediate dominator. The root and
+ * every node it does not reach are absent.
+ *
+ * `successors` is the graph as the caller sees it: a walk that cuts an edge
+ * leaves the edge out here.
+ */
+export declare function dominatorsOf(root: string, successors: (node: string) => Iterable<string>): ReadonlyMap<string, string>;
+//# sourceMappingURL=dominate.d.ts.map

package/dist/relate/dominate.js

@@ -0,0 +1,77 @@
+// compass: variance-authority.reach
+/**
+ * Dominance over a graph with one root.
+ *
+ * D dominates N when every path from the root to N passes through D; N's
+ * immediate dominator is the nearest such D, and the immediate dominators form
+ * a tree. Cooper, Harvey and Kennedy's iterative algorithm ("A Simple, Fast
+ * Dominance Algorithm", 2001): intersect the predecessors' dominators in
+ * reverse postorder until nothing changes. It holds on cycles, and on the graphs
+ * an import walk produces it settles in two or three passes.
+ */
+/**
+ * Each node the root reaches, mapped to its immediate dominator. The root and
+ * every node it does not reach are absent.
+ *
+ * `successors` is the graph as the caller sees it: a walk that cuts an edge
+ * leaves the edge out here.
+ */
+export function dominatorsOf(root, successors) {
+    // Postorder by an explicit stack: an import chain is deeper than a call stack likes.
+    const order = [];
+    const number = new Map();
+    const predecessors = new Map();
+    const seen = new Set([root]);
+    const stack = [{ node: root, next: successors(root)[Symbol.iterator]() }];
+    while (stack.length > 0) {
+        const top = stack[stack.length - 1];
+        const step = top.next.next();
+        if (step.done === true) {
+            stack.pop();
+            number.set(top.node, order.length);
+            order.push(top.node);
+            continue;
+        }
+        const child = step.value;
+        const into = predecessors.get(child);
+        if (into === undefined)
+            predecessors.set(child, [top.node]);
+        else
+            into.push(top.node);
+        if (seen.has(child))
+            continue;
+        seen.add(child);
+        stack.push({ node: child, next: successors(child)[Symbol.iterator]() });
+    }
+    const idom = new Map([[root, root]]);
+    const intersect = (left, right) => {
+        let a = left;
+        let b = right;
+        while (a !== b) {
+            while (number.get(a) < number.get(b))
+                a = idom.get(a);
+            while (number.get(b) < number.get(a))
+                b = idom.get(b);
+        }
+        return a;
+    };
+    for (let changed = true; changed;) {
+        changed = false;
+        for (let at = order.length - 2; at >= 0; at -= 1) {
+            const node = order[at];
+            let next;
+            for (const from of predecessors.get(node) ?? []) {
+                if (!idom.has(from))
+                    continue;
+                next = next === undefined ? from : intersect(from, next);
+            }
+            if (next !== undefined && idom.get(node) !== next) {
+                idom.set(node, next);
+                changed = true;
+            }
+        }
+    }
+    idom.delete(root);
+    return idom;
+}
+//# sourceMappingURL=dominate.js.map

package/dist/relate/dominate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dominate.js","sourceRoot":"","sources":["../../src/relate/dominate.ts"],"names":[],"mappings":"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","sourcesContent":["// compass: variance-authority.reach\n/**\n * Dominance over a graph with one root.\n *\n * D dominates N when every path from the root to N passes through D; N's\n * immediate dominator is the nearest such D, and the immediate dominators form\n * a tree. Cooper, Harvey and Kennedy's iterative algorithm (\"A Simple, Fast\n * Dominance Algorithm\", 2001): intersect the predecessors' dominators in\n * reverse postorder until nothing changes. It holds on cycles, and on the graphs\n * an import walk produces it settles in two or three passes.\n */\n\n/**\n * Each node the root reaches, mapped to its immediate dominator. The root and\n * every node it does not reach are absent.\n *\n * `successors` is the graph as the caller sees it: a walk that cuts an edge\n * leaves the edge out here.\n */\nexport function dominatorsOf(\n  root: string,\n  successors: (node: string) => Iterable<string>,\n): ReadonlyMap<string, string> {\n  // Postorder by an explicit stack: an import chain is deeper than a call stack likes.\n  const order: string[] = [];\n  const number = new Map<string, number>();\n  const predecessors = new Map<string, string[]>();\n  const seen = new Set([root]);\n  const stack: { node: string; next: Iterator<string> }[] = [{ node: root, next: successors(root)[Symbol.iterator]() }];\n  while (stack.length > 0) {\n    const top = stack[stack.length - 1]!;\n    const step = top.next.next();\n    if (step.done === true) {\n      stack.pop();\n      number.set(top.node, order.length);\n      order.push(top.node);\n      continue;\n    }\n    const child = step.value;\n    const into = predecessors.get(child);\n    if (into === undefined) predecessors.set(child, [top.node]);\n    else into.push(top.node);\n    if (seen.has(child)) continue;\n    seen.add(child);\n    stack.push({ node: child, next: successors(child)[Symbol.iterator]() });\n  }\n\n  const idom = new Map<string, string>([[root, root]]);\n  const intersect = (left: string, right: string): string => {\n    let a = left;\n    let b = right;\n    while (a !== b) {\n      while (number.get(a)! < number.get(b)!) a = idom.get(a)!;\n      while (number.get(b)! < number.get(a)!) b = idom.get(b)!;\n    }\n    return a;\n  };\n  for (let changed = true; changed;) {\n    changed = false;\n    for (let at = order.length - 2; at >= 0; at -= 1) {\n      const node = order[at]!;\n      let next: string | undefined;\n      for (const from of predecessors.get(node) ?? []) {\n        if (!idom.has(from)) continue;\n        next = next === undefined ? from : intersect(from, next);\n      }\n      if (next !== undefined && idom.get(node) !== next) {\n        idom.set(node, next);\n        changed = true;\n      }\n    }\n  }\n  idom.delete(root);\n  return idom;\n}\n"]}

package/dist/relate/index.d.ts

@@ -11,6 +11,9 @@
  */
 export { EDGE_KINDS, NODE_KINDS, RUNTIME_EDGES, idOf, keyOf, nodeAt, nodesOfKind, relationsOf, type Adjacency, type EdgeKind, type Node, type NodeId, type NodeKind, type Relation, type Relations, } from './graph.js';
 export { beforeReach, changedBefore, within, type BeforeReach, type BeforeReachOptions, } from './before.js';
+export { beyondReach, type BeyondReach, type InstallMoved } from './beyond.js';
+export { NOTHING, WHOLE, carried, type CarriedOptions, type CarriedStep, type Carry, type Held, type Reached, type Whole, } from './carried.js';
+export { dominatorsOf } from './dominate.js';
 export { type EdgeUse, type Uses } from './narrow.js';
 export { dependenciesOf, dependentsOf, trailOf, type Traversal, type TraversalOptions, } from './reach.js';
 export { CLOSURE_EDGES, closureOf, driftedBetween, type Closure, type ClosureInput, type Drift, } from './merkle.js';

package/dist/relate/index.js

@@ -11,6 +11,9 @@
  */
 export { EDGE_KINDS, NODE_KINDS, RUNTIME_EDGES, idOf, keyOf, nodeAt, nodesOfKind, relationsOf, } from './graph.js';
 export { beforeReach, changedBefore, within, } from './before.js';
+export { beyondReach } from './beyond.js';
+export { NOTHING, WHOLE, carried, } from './carried.js';
+export { dominatorsOf } from './dominate.js';
 export {} from './narrow.js';
 export { dependenciesOf, dependentsOf, trailOf, } from './reach.js';
 export { CLOSURE_EDGES, closureOf, driftedBetween, } from './merkle.js';

package/dist/relate/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/relate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,IAAI,EACJ,KAAK,EACL,MAAM,EACN,WAAW,EACX,WAAW,GAQZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,WAAW,EACX,aAAa,EACb,MAAM,GAGP,MAAM,aAAa,CAAC;AAErB,OAAO,EAA2B,MAAM,aAAa,CAAC;AAEtD,OAAO,EACL,cAAc,EACd,YAAY,EACZ,OAAO,GAGR,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,aAAa,EACb,SAAS,EACT,cAAc,GAIf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,OAAO,EACP,UAAU,EACV,gBAAgB,GAOjB,MAAM,cAAc,CAAC","sourcesContent":["/**\n * `core/relate` — what reaches what.\n *\n * A typed, interned, bidirectional graph and the two traversals over it, plus the\n * file-shaped record the scanner produces and the fold that turns a pile of them\n * into the structure. No I/O, no parser, no resolver: the expensive half belongs\n * to whoever owns the disk, and this is the half that has to be fast and has to\n * be provable without one.\n *\n * See [`docs/selecting.md`](../../../../docs/selecting.md) for what it is for.\n */\n\nexport {\n  EDGE_KINDS,\n  NODE_KINDS,\n  RUNTIME_EDGES,\n  idOf,\n  keyOf,\n  nodeAt,\n  nodesOfKind,\n  relationsOf,\n  type Adjacency,\n  type EdgeKind,\n  type Node,\n  type NodeId,\n  type NodeKind,\n  type Relation,\n  type Relations,\n} from './graph.js';\n\nexport {\n  beforeReach,\n  changedBefore,\n  within,\n  type BeforeReach,\n  type BeforeReachOptions,\n} from './before.js';\n\nexport { type EdgeUse, type Uses } from './narrow.js';\n\nexport {\n  dependenciesOf,\n  dependentsOf,\n  trailOf,\n  type Traversal,\n  type TraversalOptions,\n} from './reach.js';\n\nexport {\n  CLOSURE_EDGES,\n  closureOf,\n  driftedBetween,\n  type Closure,\n  type ClosureInput,\n  type Drift,\n} from './merkle.js';\n\nexport {\n  explain,\n  affectedBy,\n  relationsOfFiles,\n  type FileEdge,\n  type FileRecord,\n  type AffectedOptions,\n  type PackageEdge,\n  type RelationsOptions,\n  type Affected,\n} from './records.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/relate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,IAAI,EACJ,KAAK,EACL,MAAM,EACN,WAAW,EACX,WAAW,GAQZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,WAAW,EACX,aAAa,EACb,MAAM,GAGP,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,WAAW,EAAuC,MAAM,aAAa,CAAC;AAE/E,OAAO,EACL,OAAO,EACP,KAAK,EACL,OAAO,GAOR,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAA2B,MAAM,aAAa,CAAC;AAEtD,OAAO,EACL,cAAc,EACd,YAAY,EACZ,OAAO,GAGR,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,aAAa,EACb,SAAS,EACT,cAAc,GAIf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,OAAO,EACP,UAAU,EACV,gBAAgB,GAOjB,MAAM,cAAc,CAAC","sourcesContent":["/**\n * `core/relate` — what reaches what.\n *\n * A typed, interned, bidirectional graph and the two traversals over it, plus the\n * file-shaped record the scanner produces and the fold that turns a pile of them\n * into the structure. No I/O, no parser, no resolver: the expensive half belongs\n * to whoever owns the disk, and this is the half that has to be fast and has to\n * be provable without one.\n *\n * See [`docs/selecting.md`](../../../../docs/selecting.md) for what it is for.\n */\n\nexport {\n  EDGE_KINDS,\n  NODE_KINDS,\n  RUNTIME_EDGES,\n  idOf,\n  keyOf,\n  nodeAt,\n  nodesOfKind,\n  relationsOf,\n  type Adjacency,\n  type EdgeKind,\n  type Node,\n  type NodeId,\n  type NodeKind,\n  type Relation,\n  type Relations,\n} from './graph.js';\n\nexport {\n  beforeReach,\n  changedBefore,\n  within,\n  type BeforeReach,\n  type BeforeReachOptions,\n} from './before.js';\n\nexport { beyondReach, type BeyondReach, type InstallMoved } from './beyond.js';\n\nexport {\n  NOTHING,\n  WHOLE,\n  carried,\n  type CarriedOptions,\n  type CarriedStep,\n  type Carry,\n  type Held,\n  type Reached,\n  type Whole,\n} from './carried.js';\n\nexport { dominatorsOf } from './dominate.js';\n\nexport { type EdgeUse, type Uses } from './narrow.js';\n\nexport {\n  dependenciesOf,\n  dependentsOf,\n  trailOf,\n  type Traversal,\n  type TraversalOptions,\n} from './reach.js';\n\nexport {\n  CLOSURE_EDGES,\n  closureOf,\n  driftedBetween,\n  type Closure,\n  type ClosureInput,\n  type Drift,\n} from './merkle.js';\n\nexport {\n  explain,\n  affectedBy,\n  relationsOfFiles,\n  type FileEdge,\n  type FileRecord,\n  type AffectedOptions,\n  type PackageEdge,\n  type RelationsOptions,\n  type Affected,\n} from './records.js';\n"]}

package/dist/relate/merkle.js

@@ -46,6 +46,7 @@
  * left to a recorded run, which sees the module load whatever named it.
  */
 import { digestCombine, digestString } from '../format/hash.js';
+import { allowedKinds } from './carried.js';
 import { EDGE_KINDS, NODE_KINDS, keyOf, } from './graph.js';
 /**
  * Hash every node over its own content and its whole dependency closure.
@@ -56,7 +57,7 @@ import { EDGE_KINDS, NODE_KINDS, keyOf, } from './graph.js';
  */
 export function closureOf(input) {
     const { relations, content } = input;
-    const allowed = allowedKinds(input.through);
+    const allowed = allowedKinds(input.through, CLOSURE_EDGES);
     const count = relations.names.length;
     const { component, order } = condense(relations, allowed);
     const digests = new Map();
@@ -243,16 +244,6 @@ export const CLOSURE_EDGES = [
     'declared-in',
     'depends',
 ];
-/** Edge kinds as a lookup, so the inner loop tests a byte. */
-function allowedKinds(through) {
-    const allowed = new Uint8Array(EDGE_KINDS.length);
-    for (const kind of through ?? CLOSURE_EDGES) {
-        const at = EDGE_KINDS.indexOf(kind);
-        if (at !== -1)
-            allowed[at] = 1;
-    }
-    return allowed;
-}
 function byCodeUnit(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
 }