@descryy/adapter-kotlin 0.1.0

package/dist/extract.js

@@ -0,0 +1,722 @@
+/**
+ * Kotlin structures into IR nodes and edges.
+ *
+ * ## The identity rule, and why it refuses
+ *
+ * Kotlin shares `@descryy/adapter-jvm`'s anchor with Java: a symbol's identity is
+ * `module/sourceSet/package`, derived by subtracting the package path from the
+ * file's directory. Measured before this was written — okhttp 570 of 576 files
+ * derive, ktor 2,146 of 2,324.
+ *
+ * **When the subtraction fails, the node is refused.** Java falls back to the
+ * bare package name; Kotlin must not, because Kotlin Multiplatform declares one
+ * qualified name in several source sets **by design** — `expect`/`actual`. A
+ * bare-package fallback collapses those onto one id. Measured on ktor: 4 FQNs,
+ * `io.ktor.utils.io.charsets.Charsets` among them, declared across seven
+ * platform files.
+ *
+ * Disclosing the collapse on `attrs` instead was considered and rejected:
+ * nothing above the IR reads `attrs`, so scoring, governance and blast radius
+ * would act on a merged node while the note sat somewhere they cannot see.
+ * A refusal is visible to the layers that act on it; that is the whole
+ * difference (DEC-173).
+ *
+ * ## No cross-language edges, and that is a measurement
+ *
+ * The build plan has this adapter mint Java-shaped target ids for references
+ * into `.java` files. **It is not implemented, because the corpus chosen to
+ * measure it cannot witness it.** okhttp's 68 `.java` files are 56 samples with
+ * `kt/` twins, 11 `module-info.java` declaring no types, and 3 `*JavaTest.java`
+ * exercising the Kotlin API. The traffic runs Java→Kotlin. ktor is 2,324 `.kt`
+ * against 1 `.java`.
+ *
+ * A rule with zero witnesses is an untaken branch, not a weak rule — so it is
+ * declared absent rather than written blind.
+ */
+import { endpointQsp, nodeId, normaliseEndpointPath, symbolQsp, } from "@descryy/ir";
+const LANGUAGE = "kotlin";
+const typeKey = (identityPackage, path) => `${identityPackage}::${path.join(".")}`;
+// identityPackage is `module[/sourceSet]/package`; the package is the segment
+// after the last slash and is what an import path states.
+const packageOf = (identityPackage) => identityPackage.slice(identityPackage.lastIndexOf("/") + 1);
+export function extract(input) {
+    const nodes = [];
+    const edges = [];
+    const unresolved = [];
+    const scope = input.scope;
+    const typesByKey = new Map();
+    const funcsByKey = new Map();
+    const moduleIdOf = new Map();
+    const seenEdges = new Set();
+    // `IREdge` carries no `language` — an edge's language is the language of the
+    // nodes it joins, and duplicating it here would be a second place for it to
+    // be wrong.
+    const push = (edge, confidence, resolution) => {
+        if (resolution > input.reached)
+            return false;
+        const key = `${edge.from}|${edge.to}|${edge.type}`;
+        if (seenEdges.has(key))
+            return true;
+        seenEdges.add(key);
+        edges.push({ ...edge, confidence, producedBy: input.producedBy, resolution });
+        return true;
+    };
+    const refuse = (fromNodeId, edgeType, rawTarget, file, line, reason, attrs) => {
+        unresolved.push({
+            fromNodeId,
+            edgeType,
+            rawTarget,
+            file,
+            line,
+            producedBy: input.producedBy,
+            reason,
+            ...(attrs === undefined ? {} : { attrs }),
+        });
+    };
+    // -------------------------------------------------------------------------
+    // Pass 0 — count declarations sharing an identity key: same identityPackage,
+    // same owner chain, same name. Two shapes produce this, and both share one
+    // cause: this adapter's identity has no parameter-type or file component to
+    // break the tie, by design (DEC-004 — a file component churns on rename).
+    //
+    //  - Two files in one package each declaring a top-level `fun main()`. The
+    //    JVM synthesises a distinct `FileNameKt` class per file; nothing here
+    //    does. okhttp's `samples/` alone has 20+ such files.
+    //  - Overloads: two methods on the same class sharing a name over different
+    //    parameters, which this adapter cannot distinguish without a type
+    //    checker. Measured on ktor: `AuthenticationConfig.provider(name)` and
+    //    `.provider(name, configure, body)` collide; the second's own body is
+    //    the one that calls `requireProviderNotRegistered`, and it was silently
+    //    unreachable through the merged node.
+    //
+    // Pass 1 used to keep the first declaration under a key and silently drop
+    // the rest with no disclosure — a rule-7 violation — which cross-attributes
+    // every edge that belonged to a dropped declaration onto whichever one
+    // happened to parse first, rather than losing them cleanly.
+    // -------------------------------------------------------------------------
+    const declNameCount = new Map();
+    for (const unit of input.files) {
+        if (unit.identityPackage === undefined)
+            continue;
+        for (const decl of unit.decls) {
+            const k = `type::${typeKey(unit.identityPackage, [...decl.owners, decl.name])}`;
+            declNameCount.set(k, (declNameCount.get(k) ?? 0) + 1);
+        }
+        for (const fn of unit.funcs) {
+            const k = `func::${typeKey(unit.identityPackage, [...fn.owners, fn.name])}`;
+            declNameCount.set(k, (declNameCount.get(k) ?? 0) + 1);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Pass 1 — declarations. A file with no derivable identity package mints
+    // nothing at all, and says so once for the file rather than once per symbol.
+    // -------------------------------------------------------------------------
+    for (const unit of input.files) {
+        if (unit.identityPackage === undefined) {
+            refuse("", "IMPORTS", unit.file, unit.file, 1, "This file does not sit where its package declaration says it should, so its module and " +
+                "source set cannot be derived. Anchoring on the package alone would give two files in " +
+                "different source sets one identity — which Kotlin Multiplatform produces deliberately " +
+                "via expect/actual — so no node is emitted for this file. Measured: 4 such collisions on " +
+                "ktor, 0 on okhttp.");
+            continue;
+        }
+        const moduleId = nodeId(scope, "MODULE", symbolQsp(unit.identityPackage, [fileStem(unit.file)]), LANGUAGE);
+        moduleIdOf.set(unit.file, moduleId);
+        nodes.push({
+            id: moduleId,
+            type: "MODULE",
+            name: fileStem(unit.file),
+            file: unit.file,
+            range: { startLine: 1, endLine: 1 },
+            language: LANGUAGE,
+            producedBy: input.producedBy,
+            resolution: 0,
+            attrs: {
+                packageName: unit.packageName,
+                ...(unit.hasError ? { parsedWithErrors: true } : {}),
+            },
+        });
+        // Counted in parse.ts, disclosed here. Silence is the worst direction under
+        // rule 7, and a declaration this adapter deliberately declined to place is
+        // exactly the thing a reader would otherwise assume absent from the source.
+        if (unit.unparseableDeclarations > 0) {
+            refuse(moduleId, "IMPORTS", fileStem(unit.file), unit.file, 1, `${unit.unparseableDeclarations} declaration(s) in this file could not be placed. The pinned ` +
+                "grammar does not parse Kotlin's `fun interface`, so the body arrives as an orphaned lambda " +
+                "and its nested types would be minted at package level — a wrong owner rather than a missing " +
+                "one. They are declined instead.");
+        }
+        if (unit.anonymousMembers > 0) {
+            refuse(moduleId, "CALLS", fileStem(unit.file), unit.file, 1, `${unit.anonymousMembers} member(s) of anonymous \`object : X {}\` declarations in this file ` +
+                "have no qualified symbol path and are not emitted.");
+        }
+        for (const decl of unit.decls) {
+            const path = [...decl.owners, decl.name];
+            const key = typeKey(unit.identityPackage, path);
+            const typeCollisions = declNameCount.get(`type::${key}`) ?? 0;
+            if (typeCollisions > 1) {
+                refuse(moduleId, "IMPORTS", decl.name, unit.file, decl.startLine, `${typeCollisions} declarations named "${path.join(".")}" share one identity in package ` +
+                    `"${packageOf(unit.identityPackage)}" — this adapter has no parameter-type or file component to ` +
+                    "tell them apart. Refused rather than merged onto one arbitrary winner.");
+                continue;
+            }
+            if (typesByKey.has(key))
+                continue;
+            const id = nodeId(scope, "CLASS", symbolQsp(unit.identityPackage, path), LANGUAGE);
+            typesByKey.set(key, { id, kind: decl.kind, identityPackage: unit.identityPackage, file: unit.file, path });
+            nodes.push({
+                id,
+                type: "CLASS",
+                name: decl.name,
+                file: unit.file,
+                range: { startLine: decl.startLine, endLine: decl.endLine },
+                language: LANGUAGE,
+                producedBy: input.producedBy,
+                resolution: 0,
+                attrs: { declarationForm: decl.kind },
+            });
+        }
+        for (const fn of unit.funcs) {
+            const path = [...fn.owners, fn.name];
+            const key = typeKey(unit.identityPackage, path);
+            const funcCollisions = declNameCount.get(`func::${key}`) ?? 0;
+            if (funcCollisions > 1) {
+                refuse(moduleId, "IMPORTS", fn.name, unit.file, fn.startLine, `${funcCollisions} functions named "${path.join(".")}" share one identity in package ` +
+                    `"${packageOf(unit.identityPackage)}" — this adapter has no parameter-type or file component to tell ` +
+                    "an overload, or two same-named top-level declarations, apart. Refused rather than merged onto one arbitrary winner.");
+                continue;
+            }
+            const id = fn.isTest
+                ? nodeId(scope, "TEST_CASE", symbolQsp(unit.identityPackage, path), LANGUAGE)
+                : nodeId(scope, "FUNCTION", symbolQsp(unit.identityPackage, path), LANGUAGE);
+            if (funcsByKey.has(key))
+                continue;
+            funcsByKey.set(key, { id, identityPackage: unit.identityPackage, owners: fn.owners, name: fn.name, file: unit.file });
+            nodes.push({
+                id,
+                type: fn.isTest ? "TEST_CASE" : "FUNCTION",
+                name: fn.name,
+                file: unit.file,
+                range: { startLine: fn.startLine, endLine: fn.endLine },
+                language: LANGUAGE,
+                producedBy: input.producedBy,
+                resolution: 0,
+                attrs: fn.isTest
+                    ? { suite: fn.owners.join("."), owner: fn.owners.join("."), testStyle: fn.testStyle }
+                    : fn.owners.length > 0
+                        ? { owner: fn.owners.join(".") }
+                        : {},
+            });
+        }
+    }
+    // Fields land on the owning type, which is what patterns 05/06 read.
+    for (const unit of input.files) {
+        if (unit.identityPackage === undefined)
+            continue;
+        const byOwner = new Map();
+        for (const property of unit.properties) {
+            const key = typeKey(unit.identityPackage, property.owners);
+            byOwner.set(key, [...(byOwner.get(key) ?? []), { name: property.name, type: property.type }]);
+        }
+        for (const [key, fields] of byOwner) {
+            const declared = typesByKey.get(key);
+            if (declared === undefined)
+                continue;
+            const index = nodes.findIndex((n) => n.id === declared.id);
+            if (index === -1)
+                continue;
+            const node = nodes[index];
+            if (node === undefined)
+                continue;
+            nodes[index] = {
+                ...node,
+                attrs: {
+                    ...node.attrs,
+                    // `type` is the element type and `list` a boolean, per the contract
+                    // Lane E stated and every other adapter follows. Kotlin infers, so an
+                    // absent type is "not written", never "no type".
+                    fields: fields.map((f) => ({ name: f.name, type: f.type ?? null, list: false })),
+                },
+            };
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Pass 2 — edges.
+    // -------------------------------------------------------------------------
+    /** Types a file can name: its own package, plus everything it imports. */
+    function resolveType(unit, written) {
+        if (unit.identityPackage === undefined)
+            return undefined;
+        // A written type may be a dotted path to a NESTED type —
+        // `DiskLruCache.Snapshot`. The whole path is tried first, because resolving
+        // it to its outermost segment is how `snapshot.getSource()` came to be
+        // refused against `DiskLruCache`, where the member genuinely is not.
+        const segments = written.split(".");
+        const name = segments[segments.length - 1];
+        if (segments.length > 1) {
+            const nested = typesByKey.get(typeKey(unit.identityPackage, segments));
+            if (nested !== undefined)
+                return nested;
+            // The enclosing type may be imported from another package while the path
+            // is written relative to it, so the tail is matched against declared
+            // paths rather than assumed to be package-local.
+            const byPath = [...typesByKey.values()].filter((candidate) => candidate.path.join(".").endsWith(segments.join(".")));
+            if (byPath.length === 1)
+                return byPath[0];
+            if (byPath.length > 1)
+                return undefined;
+        }
+        // Innermost-outward: a nested type shadows a package-level one.
+        const own = typesByKey.get(typeKey(unit.identityPackage, [name]));
+        if (own !== undefined)
+            return own;
+        for (const candidate of typesByKey.values()) {
+            if (candidate.identityPackage !== unit.identityPackage)
+                continue;
+            if (candidate.path[candidate.path.length - 1] === name)
+                return candidate;
+        }
+        // An explicit import names the symbol; a wildcard names its package. Both
+        // are matched against the DECLARATION table rather than assumed to exist —
+        // an import of something this adapter never read resolves to nothing and is
+        // refused, not invented.
+        const matches = [];
+        for (const imported of unit.imports) {
+            const wanted = imported.isWildcard ? name : imported.path.split(".").pop();
+            if (wanted !== name && imported.alias !== name)
+                continue;
+            for (const candidate of typesByKey.values()) {
+                if (candidate.path[candidate.path.length - 1] !== name)
+                    continue;
+                matches.push(candidate);
+            }
+        }
+        // Two candidates and no way to choose is an ambiguity, not a coin flip.
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1)
+            return undefined;
+        // Same declared PACKAGE name, but a different source set — `src/test/kotlin`
+        // naming a class in `src/main/kotlin` with no import, which Kotlin compiles
+        // without one because a test source set's classpath includes main. Tried
+        // last, and only when there is exactly one candidate: two declarations
+        // sharing a package name across different SOURCE SETS OR MODULES is the
+        // exact collision `adapter-jvm`'s identity design exists to catch (airbyte's
+        // `RedisDataFactory`, declared under both `src/test/java` and
+        // `src/test-integration/java`) — so ambiguity here still refuses rather than
+        // guesses, the same rule Java's own `pick` applies.
+        if (unit.packageName === "")
+            return undefined;
+        const samePackageName = [...typesByKey.values()].filter((candidate) => packageOf(candidate.identityPackage) === unit.packageName &&
+            candidate.path[candidate.path.length - 1] === name);
+        return samePackageName.length === 1 ? samePackageName[0] : undefined;
+    }
+    function memberOf(owner, name) {
+        return funcsByKey.get(typeKey(owner.identityPackage, [...owner.path, name]));
+    }
+    /**
+     * A top-level function a bare unqualified call may name: one in the file's
+     * own package, or one reached through an explicit or wildcard import.
+     *
+     * The same gap `resolveType` closes for types, but for functions: an
+     * unqualified call to an imported top-level function (`validateOrder`,
+     * imported from a different package) was refused as "no declaration" because
+     * this lookup only ever checked the caller's OWN package. Kotlin needs no
+     * import for a same-package call, which is what made the gap invisible until
+     * a construct genuinely needing a cross-package import existed to hit it.
+     */
+    function resolveFreeFunction(unit, name) {
+        if (unit.identityPackage === undefined)
+            return undefined;
+        const own = funcsByKey.get(typeKey(unit.identityPackage, [name]));
+        if (own !== undefined)
+            return own;
+        const matches = [];
+        for (const imported of unit.imports) {
+            if (!imported.isWildcard) {
+                const tail = imported.path.split(".").pop();
+                if (tail !== name && imported.alias !== name)
+                    continue;
+            }
+            for (const fn of funcsByKey.values()) {
+                if (fn.owners.length > 0)
+                    continue; // a member, not a free function
+                if (fn.name !== name)
+                    continue;
+                const fqn = `${packageOf(fn.identityPackage)}.${fn.name}`;
+                if (imported.isWildcard ? packageOf(fn.identityPackage) !== imported.path : fqn !== imported.path)
+                    continue;
+                matches.push(fn);
+            }
+        }
+        // Two candidates and no way to choose is an ambiguity, not a coin flip —
+        // the same rule `resolveType` applies to an imported type name.
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1)
+            return undefined;
+        // Same declared package, different source set — see `resolveType`'s
+        // identical fallback for the reasoning; a bare call to a same-package
+        // top-level function needs it exactly as a bare type reference does.
+        if (unit.packageName === "")
+            return undefined;
+        const samePackageName = [...funcsByKey.values()].filter((fn) => fn.owners.length === 0 && fn.name === name && packageOf(fn.identityPackage) === unit.packageName);
+        return samePackageName.length === 1 ? samePackageName[0] : undefined;
+    }
+    for (const unit of input.files) {
+        if (unit.identityPackage === undefined)
+            continue;
+        const moduleId = moduleIdOf.get(unit.file);
+        // IMPORTS — file-granular, to the module of the imported symbol.
+        if (moduleId !== undefined) {
+            for (const imported of unit.imports) {
+                // A STAR IMPORT IS REFUSED. `import io.ktor.util.*` names a package,
+                // and the IR has no PACKAGE node — so the only available edge is
+                // MODULE->MODULE, once per file in that package. Measured on ktor: 144
+                // of 183 sampled such edges point at a file whose declarations the
+                // importing file never names anywhere in its text, and ktor writes
+                // 9,222 star imports against 4,877 explicit ones.
+                //
+                // That made IMPORTS 89,080 of 98,551 edges at roughly 79% wrong — 90%
+                // of the graph, and the single reason both precision gates failed.
+                // Rule 2 decides it: a wrong edge corrupts every layer above, a missing
+                // one is a disclosed gap.
+                if (imported.isWildcard) {
+                    refuse(moduleId, "IMPORTS", `${imported.path}.*`, unit.file, imported.line, "A star import names a package, and the IR has no PACKAGE node. The only edge " +
+                        "available is one per file in that package, and most of those files declare nothing " +
+                        "this file uses — measured at roughly 79% wrong on a reference repository. Refused " +
+                        "rather than emitted; the dependency is real but not expressible at this resolution.");
+                    continue;
+                }
+                // An explicit import is matched on its FULL PACKAGE PATH, not on the
+                // last segment. Matching by simple name gave `import okhttp3.Request` an
+                // edge to a nested `data class Request` inside another Gradle module's
+                // ShadowDnsResolver, and made mockwebserver and mockwebserver-deprecated
+                // resolve into each other in both directions.
+                const wanted = imported.path;
+                const targets = new Set();
+                for (const candidate of typesByKey.values()) {
+                    const fqn = `${packageOf(candidate.identityPackage)}.${candidate.path.join(".")}`;
+                    if (fqn !== wanted)
+                        continue;
+                    const target = moduleIdOf.get(candidate.file);
+                    if (target !== undefined && target !== moduleId)
+                        targets.add(target);
+                }
+                // A Kotlin import may name a TOP-LEVEL FUNCTION or property, not only a
+                // type — `import io.ktor.server.request.receive` is an extension
+                // function. Matching only against types made 21 of 22 adjudicated wrong
+                // refusals on ktor, and the shape looked like a filename problem from
+                // the outside because the declaring file is named for its subject
+                // (`ApplicationReceiveFunctions.kt`) rather than for the symbol.
+                if (targets.size === 0) {
+                    for (const fn of funcsByKey.values()) {
+                        if (fn.owners.length > 0)
+                            continue; // a member, not importable alone
+                        if (`${packageOf(fn.identityPackage)}.${fn.name}` !== wanted)
+                            continue;
+                        const target = moduleIdOf.get(fn.file);
+                        if (target !== undefined && target !== moduleId)
+                            targets.add(target);
+                    }
+                }
+                if (targets.size === 0) {
+                    refuse(moduleId, "IMPORTS", imported.path, unit.file, imported.line, "No declaration for this import in the analysed set — it is a dependency, a standard " +
+                        "library symbol, or a file outside the parsed tree.");
+                    continue;
+                }
+                for (const target of targets)
+                    push({ from: moduleId, to: target, type: "IMPORTS" }, 0.9, 1);
+            }
+        }
+        // Supertypes — decided against the table, never from syntax alone.
+        for (const decl of unit.decls) {
+            const subject = typesByKey.get(typeKey(unit.identityPackage, [...decl.owners, decl.name]));
+            if (subject === undefined)
+                continue;
+            for (const supertype of decl.supertypes) {
+                const target = resolveType(unit, supertype.name);
+                if (target === undefined) {
+                    refuse(subject.id, "IMPLEMENTS", supertype.name, unit.file, supertype.line, "No declaration for this supertype in the analysed set — it is a dependency or a " +
+                        "standard library type.");
+                    continue;
+                }
+                const edgeType = classifySupertype(target, supertype);
+                push({ from: subject.id, to: target.id, type: edgeType }, edgeType === "INHERITS" ? 0.95 : 0.9, 1);
+            }
+        }
+        // Calls.
+        for (const fn of unit.funcs) {
+            const from = funcsByKey.get(typeKey(unit.identityPackage, [...fn.owners, fn.name]));
+            if (from === undefined)
+                continue;
+            for (const ref of fn.refs) {
+                if (ref.kind === "type") {
+                    const target = resolveType(unit, ref.name);
+                    if (target !== undefined)
+                        push({ from: from.id, to: target.id, type: "USES_TYPE" }, 0.85, 1);
+                    continue;
+                }
+                if (!ref.hasReceiver) {
+                    // A bare call: a top-level function (own package or imported), or a
+                    // member of the enclosing type.
+                    const enclosing = fn.owners.length > 0
+                        ? typesByKey.get(typeKey(unit.identityPackage, fn.owners))
+                        : undefined;
+                    const member = enclosing === undefined ? undefined : memberOf(enclosing, ref.name);
+                    const free = resolveFreeFunction(unit, ref.name);
+                    const target = member ?? free;
+                    if (target === undefined) {
+                        // A constructor invocation is syntactically identical to a call —
+                        // Kotlin has no `new` keyword — so a name that resolves to a TYPE
+                        // rather than a function is a class or enum named as a VALUE
+                        // (DEC-068), not a missing declaration.
+                        const asType = resolveType(unit, ref.name);
+                        if (asType !== undefined) {
+                            push({ from: from.id, to: asType.id, type: "USES_TYPE" }, 0.85, 1);
+                            continue;
+                        }
+                        refuse(from.id, "CALLS", ref.name, unit.file, ref.line, "No declaration for this name in the analysed set.");
+                        continue;
+                    }
+                    push({ from: from.id, to: target.id, type: "CALLS" }, 0.85, 1);
+                    continue;
+                }
+                if (ref.receiverType === undefined) {
+                    // The receiver has no written LOCAL type — but the receiver name
+                    // itself may resolve to a declared type, which is `object`,
+                    // `companion object` and static-style access: `Routes.getOrder(id)`
+                    // has no local variable named `Routes` to look up, because `Routes`
+                    // IS the type. Tried before refusing, not instead of the ordinary
+                    // path — a local variable always wins when one exists.
+                    const asStatic = ref.receiver === undefined ? undefined : resolveType(unit, ref.receiver);
+                    const staticMember = asStatic === undefined ? undefined : memberOf(asStatic, ref.name);
+                    if (staticMember !== undefined) {
+                        push({ from: from.id, to: staticMember.id, type: "CALLS" }, 0.9, 1);
+                        continue;
+                    }
+                    refuse(from.id, "CALLS", ref.name, unit.file, ref.line, ref.receiver === undefined
+                        ? "The receiver is an expression, so it has no written type at this reference. " +
+                            "Resolving it needs a type checker (R3)."
+                        : `The type of receiver "${ref.receiver}" is not written at this reference. Kotlin ` +
+                            "infers it; recovering it needs a type checker (R3).");
+                    continue;
+                }
+                const owner = resolveType(unit, ref.receiverType);
+                const target = owner === undefined ? undefined : memberOf(owner, ref.name);
+                if (target === undefined) {
+                    refuse(from.id, "CALLS", ref.name, unit.file, ref.line, owner === undefined
+                        ? `No declaration for receiver type "${ref.receiverType}" in the analysed set.`
+                        : `"${ref.name}" is not declared on ${owner.path.join(".")} in the analysed set. It may ` +
+                            "be inherited, an extension function, or defined in a dependency.");
+                    continue;
+                }
+                // R1, NOT R2. The ladder defines R2 as "+ LSP references/definitions"
+                // and there is no LSP here — this edge rests on a WRITTEN type
+                // annotation resolved against the declaration table, which is
+                // module/import resolution plus a piece of source text. Claiming R2 for
+                // it would be claiming a capability the adapter does not have. Raised by
+                // the lane grading this adapter, who could not read this file and asked
+                // what the 2 was backed by; the honest answer was nothing.
+                push({ from: from.id, to: target.id, type: "CALLS" }, 0.9, 1);
+            }
+        }
+    }
+    // TESTS — a test case covers what it calls.
+    for (const edge of [...edges]) {
+        if (edge.type !== "CALLS")
+            continue;
+        const source = nodes.find((n) => n.id === edge.from);
+        if (source?.type !== "TEST_CASE")
+            continue;
+        push({ from: edge.from, to: edge.to, type: "TESTS" }, edge.confidence, edge.resolution);
+    }
+    // ---------------------------------------------------------------------------
+    // Routes — Ktor's routing DSL. Last, because every ledger row is attributed
+    // to a MODULE the pass above has already minted.
+    // ---------------------------------------------------------------------------
+    const routeNodes = new Map();
+    const endpointNodes = new Map();
+    for (const unit of input.files) {
+        const moduleId = moduleIdOf.get(unit.file);
+        if (moduleId === undefined)
+            continue;
+        for (const refusal of unit.routeRefusals) {
+            refuse(moduleId, "SERVES_API", refusal.rawTarget, unit.file, refusal.line, refusal.reason);
+        }
+        // R2 and no lower — a route emitted from R0 or R1 is a claim stronger
+        // than the run that produced it, which the Normaliser rejects as
+        // RESOLUTION_EXCEEDS_BATCH.
+        if (input.reached < 2)
+            continue;
+        for (const route of unit.routes) {
+            const template = normaliseEndpointPath(route.template);
+            const name = `${route.method} ${route.template}`;
+            const routeId = nodeId(scope, "API_ROUTE", name, LANGUAGE);
+            if (!routeNodes.has(routeId)) {
+                routeNodes.set(routeId, {
+                    id: routeId,
+                    type: "API_ROUTE",
+                    name,
+                    file: unit.file,
+                    range: { startLine: route.line, endLine: route.line },
+                    language: LANGUAGE,
+                    producedBy: input.producedBy,
+                    resolution: 2,
+                    attrs: {
+                        method: route.method,
+                        pathTemplate: template,
+                        rawTemplate: route.template,
+                        written: route.written,
+                        framework: route.framework,
+                    },
+                });
+            }
+            // Fileless, language-less, minted with the SAME endpointQsp every other
+            // producer uses (DEC-115) — two producers that mint different ids do
+            // not conflict, they silently fail to join.
+            const endpointId = nodeId(scope, "API_ENDPOINT", endpointQsp(route.method, route.template), null);
+            if (!endpointNodes.has(endpointId)) {
+                endpointNodes.set(endpointId, {
+                    id: endpointId,
+                    type: "API_ENDPOINT",
+                    name: `${route.method} ${template}`,
+                    file: null,
+                    range: null,
+                    language: null,
+                    producedBy: input.producedBy,
+                    resolution: 2,
+                    attrs: { method: route.method, pathTemplate: template },
+                });
+            }
+            push({ from: routeId, to: endpointId, type: "SERVES_API" }, 0.9, 2);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Client calls — the caller half. Minted through the same `endpointQsp`, so a
+    // call and the route that serves it land on ONE endpoint node rather than two
+    // that never meet.
+    // ---------------------------------------------------------------------------
+    /**
+     * DEC-242's `attrs.blockedBy`/`attrs.refusalClass`, plus the diagnostic-only
+     * `argumentKind` — `undefined` when `refusalClass` was never set, so
+     * `refuse` omits `attrs` entirely rather than sending it with an
+     * `undefined` field (unset stays legal and means unclassified).
+     */
+    const clientAttrsOf = (refusal) => refusal.refusalClass === undefined
+        ? undefined
+        : {
+            blockedBy: refusal.blockedBy,
+            refusalClass: refusal.refusalClass,
+            ...(refusal.argumentKind === undefined ? {} : { argumentKind: refusal.argumentKind }),
+        };
+    for (const unit of input.files) {
+        const moduleId = moduleIdOf.get(unit.file);
+        if (moduleId === undefined)
+            continue;
+        for (const refusal of unit.clientRefusals) {
+            refuse(moduleId, "USES_API", refusal.rawTarget, unit.file, refusal.line, refusal.reason, clientAttrsOf(refusal));
+        }
+        if (input.reached < 2)
+            continue;
+        for (const call of unit.clientCalls) {
+            // The caller is the innermost function whose span contains the call, so
+            // the edge starts at the thing a reader would blame. A call outside any
+            // function — a property initialiser at file scope — is attributed to the
+            // MODULE, which is the file-scoped carrier by DEC-124.
+            const enclosing = unit.funcs
+                .filter((fn) => fn.startLine <= call.line && call.line <= fn.endLine)
+                .sort((a, b) => b.startLine - a.startLine)[0];
+            // A file that does not sit where its package declaration says has no
+            // identity package, so its functions have no ids to point at (DEC-173).
+            // The MODULE still does, and it is the file-scoped carrier by DEC-124 —
+            // so the edge degrades to the file rather than being dropped.
+            const from = enclosing === undefined || unit.identityPackage === undefined
+                ? moduleId
+                : funcsByKey.get(typeKey(unit.identityPackage, [...enclosing.owners, enclosing.name]))?.id ?? moduleId;
+            const template = normaliseEndpointPath(call.path);
+            const endpointId = nodeId(scope, "API_ENDPOINT", endpointQsp(call.method, call.path), null);
+            if (!endpointNodes.has(endpointId)) {
+                endpointNodes.set(endpointId, {
+                    id: endpointId,
+                    type: "API_ENDPOINT",
+                    name: `${call.method} ${template}`,
+                    file: null,
+                    range: null,
+                    language: null,
+                    producedBy: input.producedBy,
+                    resolution: 2,
+                    attrs: { method: call.method, pathTemplate: template },
+                });
+            }
+            push({ from, to: endpointId, type: "USES_API", attrs: { client: call.client, rawPath: call.rawPath } }, 0.9, 2);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Retrofit — a declarative client interface. Unlike every call above, there is
+    // no call SITE to attribute the edge to: the annotated function's own id IS
+    // the caller, and ordinary CALLS resolution (unchanged) is what connects a
+    // real caller to it, one hop further out. See `retrofit.ts`'s own header.
+    // ---------------------------------------------------------------------------
+    for (const unit of input.files) {
+        const moduleId = moduleIdOf.get(unit.file);
+        if (moduleId === undefined)
+            continue;
+        for (const refusal of unit.retrofitRefusals) {
+            refuse(moduleId, "USES_API", refusal.rawTarget, unit.file, refusal.line, refusal.reason);
+        }
+        if (input.reached < 2)
+            continue;
+        for (const endpoint of unit.retrofitEndpoints) {
+            const from = unit.identityPackage === undefined
+                ? undefined
+                : funcsByKey.get(typeKey(unit.identityPackage, [...endpoint.owners, endpoint.funcName]))?.id;
+            if (from === undefined) {
+                // Either the file has no derivable identity, or the declaring
+                // function itself collided with another of the same name and was
+                // refused in Pass 1 — both already disclosed there. Attributing this
+                // edge to the MODULE instead would be a second, misleading claim
+                // about a function this adapter declined to name.
+                continue;
+            }
+            const template = normaliseEndpointPath(endpoint.path);
+            const endpointId = nodeId(scope, "API_ENDPOINT", endpointQsp(endpoint.method, endpoint.path), null);
+            if (!endpointNodes.has(endpointId)) {
+                endpointNodes.set(endpointId, {
+                    id: endpointId,
+                    type: "API_ENDPOINT",
+                    name: `${endpoint.method} ${template}`,
+                    file: null,
+                    range: null,
+                    language: null,
+                    producedBy: input.producedBy,
+                    resolution: 2,
+                    attrs: { method: endpoint.method, pathTemplate: template },
+                });
+            }
+            push({ from, to: endpointId, type: "USES_API", attrs: { client: "retrofit", rawPath: endpoint.written } }, 0.9, 2);
+        }
+    }
+    nodes.push(...routeNodes.values(), ...endpointNodes.values());
+    return { nodes, edges, unresolved };
+}
+/**
+ * `INHERITS` or `IMPLEMENTS`, decided against the declaration table.
+ *
+ * The parenthesised form is Kotlin's own discriminator and it is checked first
+ * — but only as a **confirmation** of what the table says. A `class` target that
+ * was invoked is unambiguously the superclass; an `interface` target is
+ * unambiguously implemented whatever the syntax. Anything else falls to
+ * `IMPLEMENTS`, which is the weaker claim of the two.
+ */
+function classifySupertype(target, written) {
+    if (target.kind === "interface")
+        return "IMPLEMENTS";
+    if (written.invoked)
+        return "INHERITS";
+    // A bare class supertype: `interface A : B` where B resolved to a class is
+    // malformed Kotlin, so the likelier reading is that the table is incomplete.
+    // IMPLEMENTS understates rather than inventing an inheritance chain.
+    return target.kind === "class" ? "INHERITS" : "IMPLEMENTS";
+}
+const fileStem = (file) => file.slice(file.lastIndexOf("/") + 1).replace(/\.kt$/, "");
+//# sourceMappingURL=extract.js.map