codegraph-java 0.1.0

package/dist/graph/type-hierarchy.d.ts

@@ -0,0 +1,155 @@
+/**
+ * The type hierarchy — one derivation of "what is above this type, what is
+ * below it, and what a call through it can land on".
+ *
+ * Three surfaces ask that question. The viewer draws it as a tree above the
+ * members outline (design spec §3.10). `codegraph_explore` announces it as an
+ * interface-dispatch boundary ("`execute` → runtime dispatch to **611** types
+ * implementing `INodeType`"). `codegraph_node` shows the same relations as
+ * chips. Three derivations would eventually disagree about the ONE number that
+ * matters — how many implementations a call can reach — and a reader holding
+ * two of them has no way to tell which is lying. So the walk lives here once,
+ * and each caller renders it: `src/ui-server/api/node.ts` turns it into
+ * `WireHierarchy`, `ToolHandler.buildPolymorphicBoundaries` into prose.
+ *
+ * Everything here is query-time and read-only. No edge is invented: the tree is
+ * exactly the `extends`/`implements` edges the graph holds, and the one thing
+ * that is *derived* — which members override an ancestor's — is derived by name
+ * within a chain the graph already links, and is labelled as a match rather
+ * than as an `overrides` edge (nothing in the engine emits one).
+ *
+ * ## Why the fan is the interesting direction
+ *
+ * Ancestors are a fact about the code you are reading: `class X extends Y` is
+ * written on line 1. Descendants are a fact you cannot get from the file at
+ * all — the implementations of an interface live anywhere in the repo, and they
+ * are precisely what a call through that interface dispatches to. Go makes this
+ * sharpest: `System` and `Fixed` satisfy `Clock` without either file naming the
+ * other, and the `implements` edge that links them is synthesized by the
+ * resolver (`synthesizedBy: 'go-implements'`). So the fan carries its own
+ * provenance and the caller draws a synthesized hop differently — the same
+ * honesty rule the Flow strip's dashed connectors follow.
+ */
+import type CodeGraph from '../index';
+import type { Edge, EdgeKind, Node, NodeKind } from '../types';
+/** The two edge kinds that make a type hierarchy. Nothing else is a subtype. */
+export declare const HIERARCHY_EDGE_KINDS: readonly EdgeKind[];
+/**
+ * Kinds that can sit in a type hierarchy.
+ *
+ * `type_alias` is in deliberately — TypeScript's `interface A extends B` and
+ * Rust's associated types both land here, and an alias with subtypes is a real
+ * hierarchy however it was spelled. `enum` is in for Java/Kotlin/Swift, where an
+ * enum implements interfaces.
+ */
+export declare const HIERARCHY_KINDS: ReadonlySet<NodeKind>;
+/** Levels walked upward. A chain deeper than this is a generated-code artefact. */
+export declare const MAX_ANCESTOR_DEPTH = 8;
+/** Levels walked downward. Depth, not breadth — the fan itself is capped separately. */
+export declare const MAX_DESCENDANT_DEPTH = 6;
+/**
+ * Subtypes returned across the whole downward walk.
+ *
+ * A framework base class can have thousands, and the caller caps again for
+ * display; this bound is what stops the *query* from walking them. When it
+ * bites, {@link TypeHierarchy.bounded} says so — a fan that quietly stopped at
+ * 400 would read as a complete answer.
+ */
+export declare const MAX_DESCENDANTS = 400;
+/**
+ * Implementations at or above which a call through the type cannot be resolved
+ * statically at all — the same threshold `codegraph_explore` uses before it
+ * announces an interface-dispatch boundary.
+ */
+export declare const DISPATCH_MIN_IMPLEMENTERS = 8;
+/** How a subtype is tied to the type above it. */
+export type HierarchyRelation = 'extends' | 'implements';
+/** One type in the tree, and the single edge that puts it there. */
+export interface HierarchyEntry {
+    node: Node;
+    /** Steps from the focus. 1 = declared directly on the focus (either way). */
+    depth: number;
+    /**
+     * The entry one step NEARER the focus — the row this one hangs off when the
+     * tree is drawn. The focus's own id for a depth-1 entry.
+     */
+    parentId: string;
+    relation: HierarchyRelation;
+    /** The edge itself, always oriented subtype → supertype as the code declares it. */
+    edge: Edge;
+    /**
+     * The edge was synthesized rather than parsed — Go's implicit interface
+     * satisfaction, a framework registry. Drawn dashed, with its wiring site.
+     */
+    synthesized: boolean;
+    /** Direct subtypes this entry has that are NOT in the returned set. */
+    hiddenSubtypes: number;
+}
+/** A member of the focus that redeclares a member of one of its ancestors. */
+export interface OverrideMatch {
+    /** The member on the focus. */
+    memberId: string;
+    /** The member it redeclares. */
+    baseId: string;
+    /** The ancestor type that declares {@link baseId}. */
+    baseTypeId: string;
+    baseTypeName: string;
+    /** How the focus reaches that ancestor — `implements` reads as "satisfies". */
+    relation: HierarchyRelation;
+}
+/** What is above a type, what is below it, and what a call through it reaches. */
+export interface TypeHierarchy {
+    focus: Node;
+    /** Supertypes, nearest first. Ordered so the focus's own parents lead. */
+    ancestors: HierarchyEntry[];
+    /** Subtypes, breadth-first, so depth 1 is complete before depth 2 begins. */
+    descendants: HierarchyEntry[];
+    /** True number of DIRECT subtypes, whatever `descendants` was capped to. */
+    directSubtypes: number;
+    /** Of {@link directSubtypes}, the ones tied by `implements`. */
+    directImplementers: number;
+    /**
+     * The downward walk hit {@link MAX_DESCENDANTS} or {@link MAX_DESCENDANT_DEPTH}
+     * — subtypes exist that are not in `descendants`.
+     */
+    bounded: boolean;
+    /**
+     * A call through this type dispatches at runtime rather than to one target.
+     * `directImplementers >= DISPATCH_MIN_IMPLEMENTERS`.
+     */
+    polymorphic: boolean;
+    /** Members of the focus that redeclare an ancestor's, keyed by member id. */
+    overrides: Map<string, OverrideMatch>;
+}
+/**
+ * Whether a node could have a hierarchy at all.
+ *
+ * Cheap enough to gate on before doing any work: a function never has one, and
+ * the overwhelming majority of symbols a reader opens are functions.
+ */
+export declare function canHaveHierarchy(node: Node): boolean;
+/**
+ * The whole hierarchy of one type.
+ *
+ * Cost is one query per level in each direction plus one batched member read,
+ * never one per node — a base class with 400 subtypes is 2–3 queries, not 400.
+ *
+ * Returns `null` when the node cannot have a hierarchy or has no
+ * `extends`/`implements` edge in either direction, so a caller can gate on the
+ * return value rather than on the emptiness of three lists.
+ */
+export declare function buildTypeHierarchy(cg: CodeGraph, focus: Node, options?: {
+    overrides?: boolean;
+}): TypeHierarchy | null;
+/**
+ * How many distinct types extend or implement this one — the number
+ * `codegraph_explore` prints when it announces an interface dispatch and the
+ * number the viewer's fan draws.
+ *
+ * DISTINCT types, not edges: a class tied to a supertype by both an `extends`
+ * and a synthesized `implements` edge is one implementation, and a count that
+ * disagrees with the length of the list beside it is the bug this function
+ * exists to prevent.
+ */
+export declare function countImplementers(cg: CodeGraph, typeId: string): number;
+//# sourceMappingURL=type-hierarchy.d.ts.map

package/dist/graph/type-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-hierarchy.d.ts","sourceRoot":"","sources":["../../src/graph/type-hierarchy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,SAAS,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE/D,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,EAAE,SAAS,QAAQ,EAA8B,CAAC;AAEnF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,QAAQ,CAShD,CAAC;AAUH,mFAAmF;AACnF,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,wFAAwF;AACxF,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,MAAM,CAAC;AAKnC;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAM3C,kDAAkD;AAClD,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,YAAY,CAAC;AAEzD,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,oFAAoF;IACpF,IAAI,EAAE,IAAI,CAAC;IACX;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,uEAAuE;IACvE,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAED,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,IAAI,CAAC;IACZ,0EAA0E;IAC1E,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,6EAA6E;IAC7E,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,4EAA4E;IAC5E,cAAc,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,6EAA6E;IAC7E,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACvC;AAMD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAEpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,SAAS,EACb,KAAK,EAAE,IAAI,EACX,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACpC,aAAa,GAAG,IAAI,CAiBtB;AAoQD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAOvE"}

package/dist/graph/type-hierarchy.js

@@ -0,0 +1,382 @@
+"use strict";
+/**
+ * The type hierarchy — one derivation of "what is above this type, what is
+ * below it, and what a call through it can land on".
+ *
+ * Three surfaces ask that question. The viewer draws it as a tree above the
+ * members outline (design spec §3.10). `codegraph_explore` announces it as an
+ * interface-dispatch boundary ("`execute` → runtime dispatch to **611** types
+ * implementing `INodeType`"). `codegraph_node` shows the same relations as
+ * chips. Three derivations would eventually disagree about the ONE number that
+ * matters — how many implementations a call can reach — and a reader holding
+ * two of them has no way to tell which is lying. So the walk lives here once,
+ * and each caller renders it: `src/ui-server/api/node.ts` turns it into
+ * `WireHierarchy`, `ToolHandler.buildPolymorphicBoundaries` into prose.
+ *
+ * Everything here is query-time and read-only. No edge is invented: the tree is
+ * exactly the `extends`/`implements` edges the graph holds, and the one thing
+ * that is *derived* — which members override an ancestor's — is derived by name
+ * within a chain the graph already links, and is labelled as a match rather
+ * than as an `overrides` edge (nothing in the engine emits one).
+ *
+ * ## Why the fan is the interesting direction
+ *
+ * Ancestors are a fact about the code you are reading: `class X extends Y` is
+ * written on line 1. Descendants are a fact you cannot get from the file at
+ * all — the implementations of an interface live anywhere in the repo, and they
+ * are precisely what a call through that interface dispatches to. Go makes this
+ * sharpest: `System` and `Fixed` satisfy `Clock` without either file naming the
+ * other, and the `implements` edge that links them is synthesized by the
+ * resolver (`synthesizedBy: 'go-implements'`). So the fan carries its own
+ * provenance and the caller draws a synthesized hop differently — the same
+ * honesty rule the Flow strip's dashed connectors follow.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISPATCH_MIN_IMPLEMENTERS = exports.MAX_DESCENDANTS = exports.MAX_DESCENDANT_DEPTH = exports.MAX_ANCESTOR_DEPTH = exports.HIERARCHY_KINDS = exports.HIERARCHY_EDGE_KINDS = void 0;
+exports.canHaveHierarchy = canHaveHierarchy;
+exports.buildTypeHierarchy = buildTypeHierarchy;
+exports.countImplementers = countImplementers;
+/** The two edge kinds that make a type hierarchy. Nothing else is a subtype. */
+exports.HIERARCHY_EDGE_KINDS = ['extends', 'implements'];
+/**
+ * Kinds that can sit in a type hierarchy.
+ *
+ * `type_alias` is in deliberately — TypeScript's `interface A extends B` and
+ * Rust's associated types both land here, and an alias with subtypes is a real
+ * hierarchy however it was spelled. `enum` is in for Java/Kotlin/Swift, where an
+ * enum implements interfaces.
+ */
+exports.HIERARCHY_KINDS = new Set([
+    'class',
+    'interface',
+    'struct',
+    'trait',
+    'protocol',
+    'enum',
+    'type_alias',
+    'union',
+]);
+/** Member kinds an override can be declared on. */
+const OVERRIDABLE_KINDS = new Set([
+    'method',
+    'function',
+    'property',
+    'field',
+]);
+/** Levels walked upward. A chain deeper than this is a generated-code artefact. */
+exports.MAX_ANCESTOR_DEPTH = 8;
+/** Levels walked downward. Depth, not breadth — the fan itself is capped separately. */
+exports.MAX_DESCENDANT_DEPTH = 6;
+/**
+ * Subtypes returned across the whole downward walk.
+ *
+ * A framework base class can have thousands, and the caller caps again for
+ * display; this bound is what stops the *query* from walking them. When it
+ * bites, {@link TypeHierarchy.bounded} says so — a fan that quietly stopped at
+ * 400 would read as a complete answer.
+ */
+exports.MAX_DESCENDANTS = 400;
+/** Ancestors whose members are read when matching overrides. */
+const MAX_OVERRIDE_ANCESTORS = 12;
+/**
+ * Implementations at or above which a call through the type cannot be resolved
+ * statically at all — the same threshold `codegraph_explore` uses before it
+ * announces an interface-dispatch boundary.
+ */
+exports.DISPATCH_MIN_IMPLEMENTERS = 8;
+// =============================================================================
+// The walk
+// =============================================================================
+/**
+ * Whether a node could have a hierarchy at all.
+ *
+ * Cheap enough to gate on before doing any work: a function never has one, and
+ * the overwhelming majority of symbols a reader opens are functions.
+ */
+function canHaveHierarchy(node) {
+    return exports.HIERARCHY_KINDS.has(node.kind);
+}
+/**
+ * The whole hierarchy of one type.
+ *
+ * Cost is one query per level in each direction plus one batched member read,
+ * never one per node — a base class with 400 subtypes is 2–3 queries, not 400.
+ *
+ * Returns `null` when the node cannot have a hierarchy or has no
+ * `extends`/`implements` edge in either direction, so a caller can gate on the
+ * return value rather than on the emptiness of three lists.
+ */
+function buildTypeHierarchy(cg, focus, options = {}) {
+    if (!canHaveHierarchy(focus))
+        return null;
+    const ancestors = walkAncestors(cg, focus);
+    const down = walkDescendants(cg, focus);
+    if (ancestors.length === 0 && down.entries.length === 0)
+        return null;
+    return {
+        focus,
+        ancestors,
+        descendants: down.entries,
+        directSubtypes: down.directTotal,
+        directImplementers: down.directImplementers,
+        bounded: down.bounded,
+        polymorphic: down.directImplementers >= exports.DISPATCH_MIN_IMPLEMENTERS,
+        overrides: options.overrides === false ? new Map() : matchOverrides(cg, focus, ancestors),
+    };
+}
+/**
+ * Walk up. Multiple direct parents are normal (a class extends one and
+ * implements three), so this is a BFS rather than a chain, ordered nearest
+ * first and — within a level — `extends` before `implements`, because the one
+ * that carries the implementation is the one a reader wants adjacent.
+ */
+function walkAncestors(cg, focus) {
+    const out = [];
+    const seen = new Set([focus.id]);
+    let frontier = [focus.id];
+    for (let depth = 1; depth <= exports.MAX_ANCESTOR_DEPTH && frontier.length > 0; depth++) {
+        const edges = hierarchyEdges(cg, frontier, 'up');
+        if (edges.length === 0)
+            break;
+        const nodes = cg.getNodesByIds(edges.map((e) => e.target));
+        const level = [];
+        for (const edge of edges) {
+            const node = nodes.get(edge.target);
+            if (!node || seen.has(node.id))
+                continue;
+            seen.add(node.id);
+            level.push(toEntry(node, depth, edge.source, edge));
+        }
+        sortLevel(level);
+        out.push(...level);
+        frontier = level.map((e) => e.node.id);
+    }
+    return out;
+}
+/**
+ * Walk down — the fan. Breadth-first so the cap always trims the deepest,
+ * least-relevant end: a reader looking at an interface wants its direct
+ * implementations complete before a subclass of a subclass appears at all.
+ */
+function walkDescendants(cg, focus) {
+    const entries = [];
+    const byId = new Map();
+    const seen = new Set([focus.id]);
+    let frontier = [focus.id];
+    let directTotal = 0;
+    let directImplementers = 0;
+    let bounded = false;
+    for (let depth = 1; depth <= exports.MAX_DESCENDANT_DEPTH && frontier.length > 0; depth++) {
+        const edges = hierarchyEdges(cg, frontier, 'down');
+        if (edges.length === 0)
+            break;
+        const nodes = cg.getNodesByIds(edges.map((e) => e.source));
+        // One row per subtype, not per edge: a class tied to its supertype by both
+        // a parsed `extends` and a synthesized `implements` is ONE implementation.
+        // `extends` wins the relation because it is the one written in the file.
+        const level = [];
+        const overflow = new Map();
+        const levelSeen = new Set();
+        for (const edge of edges) {
+            const node = nodes.get(edge.source);
+            if (!node || seen.has(node.id))
+                continue;
+            const existing = levelSeen.has(node.id)
+                ? level.find((e) => e.node.id === node.id)
+                : undefined;
+            if (existing) {
+                if (existing.relation === 'implements' && edge.kind === 'extends') {
+                    existing.relation = 'extends';
+                    existing.edge = edge;
+                    existing.synthesized = edge.provenance === 'heuristic';
+                }
+                continue;
+            }
+            if (depth === 1) {
+                directTotal++;
+                if (edge.kind === 'implements')
+                    directImplementers++;
+            }
+            if (entries.length + level.length >= exports.MAX_DESCENDANTS) {
+                // Stop materialising rows, but keep counting depth 1 so
+                // `directSubtypes` stays the true number.
+                bounded = true;
+                overflow.set(edge.target, (overflow.get(edge.target) ?? 0) + 1);
+                levelSeen.add(node.id);
+                continue;
+            }
+            levelSeen.add(node.id);
+            level.push(toEntry(node, depth, edge.target, edge));
+        }
+        for (const entry of level)
+            seen.add(entry.node.id);
+        sortLevel(level);
+        for (const entry of level) {
+            entries.push(entry);
+            byId.set(entry.node.id, entry);
+        }
+        for (const [parentId, count] of overflow) {
+            const parent = byId.get(parentId);
+            if (parent)
+                parent.hiddenSubtypes += count;
+        }
+        if (bounded)
+            break;
+        frontier = level.map((e) => e.node.id);
+        if (depth === exports.MAX_DESCENDANT_DEPTH && frontier.length > 0) {
+            // A level exists below the one we are about to stop at. Say so rather
+            // than letting the deepest row read as a leaf.
+            for (const edge of hierarchyEdges(cg, frontier, 'down')) {
+                if (seen.has(edge.source))
+                    continue;
+                bounded = true;
+                const parent = byId.get(edge.target);
+                if (parent)
+                    parent.hiddenSubtypes++;
+            }
+        }
+    }
+    return { entries, directTotal, directImplementers, bounded };
+}
+/** One batched edge read per level, filtered to the two hierarchy kinds. */
+function hierarchyEdges(cg, ids, direction) {
+    const kinds = [...exports.HIERARCHY_EDGE_KINDS];
+    try {
+        const edges = direction === 'up'
+            ? cg.getOutgoingEdgesFrom(ids, kinds)
+            : cg.getIncomingEdgesTo(ids, kinds);
+        // Belt and braces: the kind filter is applied in SQL, but a caller reading
+        // `entry.relation` must never see a third value.
+        return edges.filter((e) => e.kind === 'extends' || e.kind === 'implements');
+    }
+    catch {
+        return [];
+    }
+}
+function toEntry(node, depth, parentId, edge) {
+    return {
+        node,
+        depth,
+        parentId,
+        relation: edge.kind === 'implements' ? 'implements' : 'extends',
+        edge,
+        synthesized: edge.provenance === 'heuristic',
+        hiddenSubtypes: 0,
+    };
+}
+/**
+ * Deterministic order within one level: `extends` first, then by name, then by
+ * file. Never by insertion — two runs against the same index must draw the same
+ * tree, and SQLite's row order is not a promise.
+ */
+function sortLevel(level) {
+    level.sort((a, b) => (a.relation === b.relation ? 0 : a.relation === 'extends' ? -1 : 1) ||
+        a.node.name.localeCompare(b.node.name) ||
+        a.node.filePath.localeCompare(b.node.filePath) ||
+        a.node.startLine - b.node.startLine);
+}
+// =============================================================================
+// Overrides
+// =============================================================================
+/**
+ * Which of the focus's members redeclare an ancestor's.
+ *
+ * Nothing in the engine emits an `overrides` edge (the kind exists in the
+ * schema and no extractor writes one), so this is a NAME match — but a name
+ * match inside a chain the graph already established, which is exactly what
+ * every language's dispatch rule is. It is reported as a match against a named
+ * base member the reader can open, never as an edge, and it is deliberately
+ * blind to signatures: an overload set would need type resolution the graph
+ * does not have, and claiming "overrides" for the wrong overload is worse than
+ * saying which type also declares this name.
+ *
+ * Two batched queries total, whatever the ancestor count.
+ */
+function matchOverrides(cg, focus, ancestors) {
+    const result = new Map();
+    if (ancestors.length === 0)
+        return result;
+    const ownMembers = membersOf(cg, [focus.id]);
+    if (ownMembers.length === 0)
+        return result;
+    // Nearest ancestors win: a method redeclared two levels up is still reported
+    // against the type the reader would actually look in.
+    const chain = ancestors.slice(0, MAX_OVERRIDE_ANCESTORS);
+    const baseMembers = membersOf(cg, chain.map((a) => a.node.id));
+    if (baseMembers.length === 0)
+        return result;
+    const ancestorById = new Map(chain.map((a) => [a.node.id, a]));
+    const byName = new Map();
+    // `chain` is nearest-first and `membersOf` preserves the order of the ids it
+    // was given, so the first entry for a name is the nearest declaration.
+    for (const { member, ownerId } of baseMembers) {
+        if (!byName.has(member.name))
+            byName.set(member.name, { member, ownerId });
+    }
+    for (const { member } of ownMembers) {
+        if (!OVERRIDABLE_KINDS.has(member.kind))
+            continue;
+        const base = byName.get(member.name);
+        if (!base || base.member.id === member.id)
+            continue;
+        const owner = ancestorById.get(base.ownerId);
+        if (!owner)
+            continue;
+        result.set(member.id, {
+            memberId: member.id,
+            baseId: base.member.id,
+            baseTypeId: owner.node.id,
+            baseTypeName: owner.node.name,
+            relation: owner.relation,
+        });
+    }
+    return result;
+}
+/** Direct `contains` children of the given containers, in the containers' order. */
+function membersOf(cg, containerIds) {
+    if (containerIds.length === 0)
+        return [];
+    let edges;
+    try {
+        edges = cg.getOutgoingEdgesFrom(containerIds, ['contains']);
+    }
+    catch {
+        return [];
+    }
+    if (edges.length === 0)
+        return [];
+    const nodes = cg.getNodesByIds(edges.map((e) => e.target));
+    const rank = new Map(containerIds.map((id, i) => [id, i]));
+    const out = [];
+    for (const edge of edges) {
+        const member = nodes.get(edge.target);
+        if (member)
+            out.push({ member, ownerId: edge.source });
+    }
+    out.sort((a, b) => (rank.get(a.ownerId) ?? 0) - (rank.get(b.ownerId) ?? 0) ||
+        a.member.startLine - b.member.startLine);
+    return out;
+}
+// =============================================================================
+// The fan, on its own
+// =============================================================================
+/**
+ * How many distinct types extend or implement this one — the number
+ * `codegraph_explore` prints when it announces an interface dispatch and the
+ * number the viewer's fan draws.
+ *
+ * DISTINCT types, not edges: a class tied to a supertype by both an `extends`
+ * and a synthesized `implements` edge is one implementation, and a count that
+ * disagrees with the length of the list beside it is the bug this function
+ * exists to prevent.
+ */
+function countImplementers(cg, typeId) {
+    try {
+        const edges = cg.getIncomingEdgesTo([typeId], [...exports.HIERARCHY_EDGE_KINDS]);
+        return new Set(edges.map((e) => e.source)).size;
+    }
+    catch {
+        return 0;
+    }
+}
+//# sourceMappingURL=type-hierarchy.js.map

package/dist/graph/type-hierarchy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-hierarchy.js","sourceRoot":"","sources":["../../src/graph/type-hierarchy.ts"],"names":[],"mappings":"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"}