knodin 0.12.2 → 0.13.0

package/dist/src/class-consumer-page.js

@@ -0,0 +1,148 @@
+import { isDeepStrictEqual } from "node:util";
+import { compareClassConsumerKeys, } from "./class-consumer-contract.js";
+import { signClassConsumerCursor } from "./class-consumer-cursor.js";
+const positiveInt = (value, fallback) => value == null || !Number.isFinite(value) ? fallback : Math.max(1, Math.trunc(value));
+const size = (value) => Buffer.byteLength(JSON.stringify(value));
+const invalid = () => new Error("invalid class-consumer page contract");
+function validatePage(page) {
+    if ((page.targetKind !== "class" && page.targetKind !== "interface") ||
+        page.returnedCount !== page.results.length ||
+        !Number.isSafeInteger(page.count) ||
+        page.count < page.results.length ||
+        !Number.isSafeInteger(page.consumerFileCount) ||
+        page.consumerFileCount < page.files.length ||
+        (page.hasMore && page.results.length === 0))
+        throw invalid();
+    const files = new Map(page.files.map((file) => [file.file, file]));
+    if (files.size !== page.files.length)
+        throw invalid();
+    const counts = new Map();
+    for (let index = 0; index < page.results.length; index++) {
+        const row = page.results[index];
+        if (row.file !== row.key.file ||
+            row.start.byte !== row.key.startByte ||
+            row.end.byte !== row.key.endByte ||
+            row.kind !== row.key.kind ||
+            (index > 0 && compareClassConsumerKeys(page.results[index - 1].key, row.key) >= 0))
+            throw invalid();
+        const file = files.get(row.file);
+        if (!file || file.isTest !== row.isTest)
+            throw invalid();
+        counts.set(row.file, (counts.get(row.file) ?? 0) + 1);
+    }
+    for (const file of files.values()) {
+        const count = counts.get(file.file);
+        if (count === undefined ||
+            file.returnedSiteCount !== count ||
+            !Number.isSafeInteger(file.siteCount) ||
+            file.siteCount < count)
+            throw invalid();
+    }
+}
+/**
+ * Fits complete rows and all qualifications, never truncating evidence fields.
+ * The caller must return this result unchanged: no later generic budget reduction.
+ * Backend lease checks precede this pure step; continuation always names the last
+ * actually delivered key, not the last row fetched from storage.
+ */
+export function finalizeClassConsumerPage(page, options) {
+    validatePage(page);
+    const request = options.budget ?? {};
+    const tokenLimit = positiveInt(request.tokens, 16384);
+    const byteLimit = Math.min(positiveInt(request.bytes, 65536), tokenLimit * 4);
+    const itemLimit = positiveInt(request.items, 100);
+    if (byteLimit < 256)
+        throw new Error("class-consumer response budget must be at least 256 bytes");
+    let maxRows = Math.min(page.results.length, itemLimit);
+    const minimumRows = page.results.length ? 1 : 0;
+    // Protected rows alone are a strict lower bound on the complete wire size.
+    // Skip impossible prefixes without cloning/decorating/serializing the entire
+    // page for each one. Do not assume complete candidate sizes are monotonic:
+    // the last-key cursor can get shorter when crossing a filename boundary.
+    let rowArrayBytes = 2;
+    for (let index = 0; index < maxRows; index++) {
+        rowArrayBytes += size(page.results[index]) + (index > 0 ? 1 : 0);
+        if (rowArrayBytes > byteLimit) {
+            maxRows = Math.max(minimumRows, index);
+            break;
+        }
+    }
+    let requiredBytes = 0;
+    for (let length = maxRows; length >= minimumRows; length--) {
+        const results = page.results.slice(0, length);
+        const counts = new Map();
+        for (const row of results)
+            counts.set(row.file, (counts.get(row.file) ?? 0) + 1);
+        const hasMore = page.hasMore || length < page.results.length;
+        const last = results.at(-1);
+        const continuation = hasMore && last
+            ? signClassConsumerCursor({
+                v: 1,
+                type: "class-consumers",
+                queryDigest: page.queryDigest,
+                snapshotDigest: page.snapshotDigest,
+                after: last.key,
+            }, options.secret)
+            : null;
+        const metadata = {
+            byteLimit,
+            tokenLimit,
+            itemLimit,
+            serializedBytes: 0,
+            estimatedTokens: 0,
+            truncated: hasMore,
+            totals: { "$/results": page.count, "$/files": page.consumerFileCount },
+        };
+        const candidate = structuredClone({
+            pattern: "class_consumers",
+            targetIdentity: page.targetIdentity,
+            targetKind: page.targetKind,
+            count: page.count,
+            consumerFileCount: page.consumerFileCount,
+            returnedCount: length,
+            results,
+            files: page.files
+                .filter((file) => counts.has(file.file))
+                .map((file) => ({
+                ...file,
+                returnedSiteCount: counts.get(file.file),
+            })),
+            hasMore,
+            continuation,
+            classConsumerAnalysis: page.analysis,
+            indexCoverage: page.indexCoverage,
+            freshness: page.freshness,
+            responseBudget: metadata,
+        });
+        const output = options.decorate ? options.decorate(structuredClone(candidate)) : candidate;
+        if (!output || Array.isArray(output) || typeof output !== "object")
+            throw invalid();
+        if (output.available === false ||
+            (output.availability &&
+                typeof output.availability === "object" &&
+                ["unavailable", "repair-needed"].includes(String(output.availability.state))))
+            throw new Error("class-consumer evidence became unavailable; restart the query");
+        for (const key of Object.keys(candidate)) {
+            if (!isDeepStrictEqual(candidate[key], output[key]))
+                throw new Error("class-consumer decoration changed protected evidence");
+        }
+        output.responseBudget = metadata;
+        // Metadata changes its own serialized size. Recompute until the byte/token digits stabilize.
+        let stable = false;
+        for (let attempt = 0; attempt < 16; attempt++) {
+            const actual = size(output), tokens = Math.ceil(actual / 4);
+            if (metadata.serializedBytes === actual && metadata.estimatedTokens === tokens) {
+                stable = true;
+                break;
+            }
+            metadata.serializedBytes = actual;
+            metadata.estimatedTokens = tokens;
+        }
+        if (!stable)
+            throw new Error("class-consumer response serialization did not stabilize");
+        requiredBytes = metadata.serializedBytes;
+        if (requiredBytes <= byteLimit)
+            return output;
+    }
+    throw new Error(`class-consumer response budget ${byteLimit} cannot preserve qualifications and one complete page item; use at least ${requiredBytes} bytes and ${Math.ceil(requiredBytes / 4)} estimated tokens or narrow the query`);
+}

package/dist/src/cli-model.js

@@ -122,7 +122,10 @@ function addRepositoryCommands(program, capture) {
         .option("--dry-run", "report actions without mutation");
 }
 function addGraphCommands(program, capture) {
-    leaf(program, "context <task> [base]", "build compact task orientation", capture);
+    leaf(program, "context <task> [base]", "build compact task orientation or a target investigation", capture)
+        .option("--symbol <name>", "investigate a target's source, change sites, impact and tests")
+        .option("--implementations", "rank possible implementations for the task; do not select a target")
+        .addOption(option("--offset <count>", "implementation candidate page offset", "integer"));
     leaf(program, "explain <symbol> [detail]", "explain one ambiguity-safe symbol", capture);
     leaf(program, "review [base] [detail]", "review an explicit Git diff scope", capture)
         .option("--scope <scope>", "unstaged, staged, all, or compare")
@@ -165,7 +168,8 @@ function addGraphCommands(program, capture) {
         .option("--kinds <values>", "comma-separated symbol kinds")
         .option("--path <prefix>", "repo-relative path prefix")
         .option("--base <ref>", "compare file_metrics with the merge-base of this Git ref")
-        .option("--test-scope <scope>", "file_metrics scope: all, test, or production")
+        .option("--test-scope <scope>", "file_metrics/class_consumers: all, test, or production")
+        .option("--continuation <handle>", "class_consumers: resume the same target and filters")
         .option("--format <format>", "file_metrics machine output format; currently json")
         .option("--variable <name>", "flow-analysis variable")
         .option("--facets <values>", "comma-separated architecture facets")
@@ -199,7 +203,9 @@ function addBackupCommands(program, capture) {
     leaf(retention, "run", "run the installed retention policy", capture);
 }
 function addArtifactCommands(program, capture) {
-    leaf(program, "evidence <level> <file>", "deliver progressive source evidence", capture)
+    leaf(program, "evidence <level> [file]", "deliver progressive source evidence", capture)
+        .option("--files <paths>", "comma-separated bundle files; evidence or expand level")
+        .option("--already-present <handles>", "comma-separated verified bundle file handles")
         .option("--continuation <handle>", "resume an exact prior response")
         .option("--baseline-hash <sha256>", "complete baseline SHA-256")
         .addOption(option("--baseline-bytes <count>", "complete baseline UTF-8 bytes", "integer"))

package/dist/src/docs-sections.js

@@ -24,6 +24,7 @@ The \`query\` operation lets you ask precise, structured questions about your co
 
 - **callers_of <target>**: Who invokes this symbol (transitive/direct).
 - **callees_of <target>**: What other symbols does this symbol invoke.
+- **class_consumers <target>**: Direct, typed Apex class-use sites, separate from method callers and Java configuration consumers. Count means observed sites; consumerFileCount means distinct files. All tests are included by default; testScope can select test or production files. Use limit (1–1000 sites), canonical path prefix, and signed continuation with the same target/filters. Pages preserve full site ranges, source-owner identities and scope/extraction qualifications; stale continuations are rejected. Nine supported syntax roles only, not complete class-use or runtime reachability proof.
 - **tests_for <target>**: Find test files that cover this symbol.
 - **file_summary <target>**: Lists all symbols defined in a file.
 - **shortest_path <from> <to>**: Find the call-graph chain connecting two symbols.

package/dist/src/engine/apex-class-uses.js

@@ -0,0 +1,430 @@
+import { createHash } from "node:crypto";
+const fold = (value) => value.toLowerCase();
+const qualifiedIdentifier = /^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*$/;
+const spelling = (node) => node.text.replace(/\s+/g, "");
+const typeDeclarations = new Set([
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+]);
+const isTypeDeclaration = (declaration) => ["class", "interface", "enum"].includes(declaration.kind);
+function owner(node, includeSelf = false) {
+    const names = [];
+    for (let parent = includeSelf ? node : node.parent; parent; parent = parent.parent) {
+        if (typeDeclarations.has(parent.type)) {
+            const name = parent.childForFieldName("name")?.text;
+            if (name)
+                names.unshift(name);
+        }
+    }
+    return names.join(".") || null;
+}
+function positionReader(source) {
+    const lines = [0];
+    const bytes = new Uint32Array(source.length + 1);
+    let byte = 0;
+    for (let offset = 0; offset < source.length;) {
+        const point = source.codePointAt(offset) ?? 0;
+        const width = point > 0xffff ? 2 : 1;
+        bytes[offset] = byte;
+        if (width === 2)
+            bytes[offset + 1] = byte;
+        byte += point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
+        offset += width;
+        bytes[offset] = byte;
+        if (point === 10)
+            lines.push(offset);
+    }
+    return (offset) => {
+        let low = 0;
+        let high = lines.length;
+        while (low + 1 < high) {
+            const middle = (low + high) >>> 1;
+            if (lines[middle] <= offset)
+                low = middle;
+            else
+                high = middle;
+        }
+        return {
+            line: low + 1,
+            column: offset - lines[low] + 1,
+            utf16Offset: offset,
+            byte: bytes[offset],
+        };
+    };
+}
+/** No filesystem, database, graph identity, or inference work occurs during extraction. */
+export function extractApexClassUses(root, source, file) {
+    const position = positionReader(source);
+    const nodes = [];
+    const stack = [root];
+    while (stack.length) {
+        const node = stack.pop();
+        if (!node)
+            break;
+        nodes.push(node);
+        for (let index = node.namedChildren.length - 1; index >= 0; index--)
+            stack.push(node.namedChildren[index]);
+    }
+    const malformed = root.hasError() || root.text !== source;
+    const sites = [];
+    const declarations = [];
+    const heritage = [];
+    let heritageComplete = !malformed;
+    const unsupportedUses = [];
+    const valueBindings = nodes.filter((node) => [
+        "variable_declarator",
+        "formal_parameter",
+        "enhanced_for_statement",
+        "catch_formal_parameter",
+    ].includes(node.type));
+    const scopeBindings = new Map();
+    for (const binding of valueBindings) {
+        const name = binding.childForFieldName("name")?.text;
+        if (!name)
+            continue;
+        for (let scope = binding.parent; scope; scope = scope.parent) {
+            if (![
+                "class_declaration",
+                "method_declaration",
+                "constructor_declaration",
+                "trigger_declaration",
+            ].includes(scope.type))
+                continue;
+            const names = scopeBindings.get(scope.id) ?? new Set();
+            names.add(fold(name));
+            scopeBindings.set(scope.id, names);
+            break;
+        }
+    }
+    const range = (node) => ({
+        start: position(node.startIndex),
+        end: position(node.endIndex),
+    });
+    const unsupported = (node, kind) => {
+        unsupportedUses.push({ kind, qualifiedSpelling: node.text, ...range(node) });
+    };
+    const blockReason = (node, typePath) => {
+        if (malformed)
+            return "malformed-source";
+        const first = fold(typePath.split(".")[0]);
+        for (let scope = node.parent; scope; scope = scope.parent) {
+            if (![
+                "class_declaration",
+                "method_declaration",
+                "constructor_declaration",
+                "trigger_declaration",
+            ].includes(scope.type))
+                continue;
+            // Deliberately conservative across lexical blocks: false negatives remain explicit blocked facts.
+            if (scopeBindings.get(scope.id)?.has(first))
+                return "value-shadow";
+        }
+        return null;
+    };
+    const add = (node, kind, typePath = spelling(node), memberName = null) => {
+        if (!qualifiedIdentifier.test(typePath))
+            return;
+        sites.push({
+            version: 1,
+            kind,
+            qualifiedSpelling: node.text,
+            typePath,
+            memberName,
+            lexicalOwner: owner(node),
+            ...range(node),
+            blockedReason: kind === "static_field_read"
+                ? blockReason(node, typePath)
+                : malformed
+                    ? "malformed-source"
+                    : null,
+        });
+    };
+    const typeUses = (node, kind, generic = false) => {
+        if (!node)
+            return;
+        if (node.type === "scoped_type_identifier" || node.type === "type_identifier") {
+            add(node, generic
+                ? kind === "parameter_type"
+                    ? "generic_parameter_type"
+                    : "generic_type_argument"
+                : kind);
+            return;
+        }
+        for (const child of node.namedChildren)
+            typeUses(child, kind, generic || node.type === "type_arguments");
+    };
+    let isTest = false;
+    for (const node of nodes) {
+        const modifiers = node.namedChildren.find((child) => child.type === "modifiers");
+        const annotations = modifiers?.namedChildren
+            .filter((child) => child.type === "annotation")
+            .map((child) => child.childForFieldName("name")?.text ?? "") ?? [];
+        const modifierWords = modifiers?.namedChildren
+            .filter((child) => child.type === "modifier")
+            .map((child) => fold(child.text)) ?? [];
+        if (annotations.some((annotation) => fold(annotation) === "istest") ||
+            modifierWords.includes("testmethod"))
+            isTest = true;
+        if (typeDeclarations.has(node.type)) {
+            const name = node.childForFieldName("name");
+            if (name)
+                declarations.push({
+                    version: 1,
+                    kind: node.type === "class_declaration"
+                        ? "class"
+                        : node.type === "enum_declaration"
+                            ? "enum"
+                            : "interface",
+                    ownerPath: owner(node, true) ?? name.text,
+                    name: name.text,
+                    static: false,
+                    annotations,
+                    superclass: node.childForFieldName("superclass")?.namedChildren[0]?.text ?? null,
+                    ...range(name),
+                    ...(node.type === "interface_declaration" ||
+                        (() => {
+                            for (let parent = node.parent; parent; parent = parent.parent)
+                                if (parent.type === "interface_declaration")
+                                    return true;
+                            return false;
+                        })()
+                        ? { declarationRange: range(node) }
+                        : {}),
+                });
+            for (const field of ["superclass", "interfaces", "extends_interfaces"]) {
+                const inherited = field === "extends_interfaces"
+                    ? node.namedChildren.find((child) => child.type === field)
+                    : node.childForFieldName(field);
+                if (inherited) {
+                    unsupported(inherited, "inheritance");
+                    const list = inherited.namedChildren.find((child) => child.type === "type_list") ?? inherited;
+                    for (const base of list.namedChildren) {
+                        const typePath = spelling(base);
+                        const ownerPath = owner(node, true);
+                        if (ownerPath && qualifiedIdentifier.test(typePath))
+                            heritage.push({
+                                kind: field === "interfaces" ? "implements" : "extends",
+                                ownerPath,
+                                typePath,
+                                ...range(base),
+                            });
+                        else
+                            heritageComplete = false;
+                    }
+                }
+            }
+        }
+        if (node.type === "field_declaration") {
+            for (const declarator of node.namedChildren.filter((child) => child.type === "variable_declarator")) {
+                const name = declarator.childForFieldName("name");
+                const ownerPath = owner(node);
+                if (name && ownerPath)
+                    declarations.push({
+                        version: 1,
+                        kind: node.namedChildren.some((child) => child.type === "accessor_list")
+                            ? "property"
+                            : "field",
+                        ownerPath,
+                        name: name.text,
+                        static: modifierWords.includes("static"),
+                        annotations,
+                        superclass: null,
+                        ...range(name),
+                    });
+            }
+        }
+        if (node.type === "field_declaration" || node.type === "local_variable_declaration")
+            typeUses(node.childForFieldName("type"), "variable_type");
+        if (node.type === "formal_parameter")
+            typeUses(node.childForFieldName("type"), "parameter_type");
+        if (node.type === "enhanced_for_statement")
+            typeUses(node.childForFieldName("type"), "loop_variable_type");
+        if (node.type === "cast_expression")
+            typeUses(node.childForFieldName("type"), "cast");
+        if (node.type === "object_creation_expression")
+            typeUses(node.childForFieldName("type"), "constructor");
+        if (node.type === "method_declaration") {
+            const type = node.childForFieldName("type");
+            if (type)
+                unsupported(type, "return_type");
+        }
+        if (node.type === "method_invocation") {
+            const receiver = node.childForFieldName("object");
+            if (receiver && qualifiedIdentifier.test(spelling(receiver)))
+                unsupported(receiver, "static_method_receiver");
+        }
+        if (node.type !== "field_access" || node.parent?.type === "field_access")
+            continue;
+        const object = node.childForFieldName("object");
+        const fieldNode = node.childForFieldName("field");
+        if (!object || !fieldNode || !qualifiedIdentifier.test(spelling(object)))
+            continue;
+        if (fold(fieldNode.text) === "class") {
+            add(node, "class_literal", spelling(object));
+            continue;
+        }
+        if ((node.parent?.type === "assignment_expression" &&
+            node.parent.childForFieldName("left")?.id === node.id) ||
+            node.parent?.type === "update_expression") {
+            unsupported(node, "static_field_write");
+            continue;
+        }
+        add(node, "static_field_read", spelling(object), fieldNode.text);
+    }
+    const unique = new Map(sites.map((site) => [`${site.start.utf16Offset}:${site.end.utf16Offset}:${site.kind}`, site]));
+    return {
+        version: 1,
+        file,
+        sourceHash: createHash("sha256").update(source).digest("hex"),
+        parseState: malformed ? "partial" : "complete",
+        isTest: malformed ? null : isTest,
+        sites: [...unique.values()].sort((a, b) => a.start.utf16Offset - b.start.utf16Offset ||
+            a.end.utf16Offset - b.end.utf16Offset ||
+            a.kind.localeCompare(b.kind)),
+        declarations,
+        unsupportedUses,
+        heritage,
+        heritageComplete,
+        coverage: "supported-syntax-only",
+    };
+}
+/** Build once per indexed catalog revision, never once per use or by walking the filesystem. */
+export function createApexConsumerCatalog(files) {
+    const classes = new Map();
+    const members = new Map();
+    for (const file of files) {
+        for (const declaration of file.declarations) {
+            // Invalid source still contributes competitors; it must not make a valid duplicate look unique.
+            const map = isTypeDeclaration(declaration) ? classes : members;
+            const key = fold(isTypeDeclaration(declaration)
+                ? declaration.ownerPath
+                : `${declaration.ownerPath}.${declaration.name}`);
+            const entries = map.get(key) ?? [];
+            entries.push({ file: file.file, parseState: file.parseState, declaration });
+            map.set(key, entries);
+        }
+    }
+    return { classes, members };
+}
+export function resolveApexClassUses(catalog, facts) {
+    const uniqueOwner = (entry) => {
+        const parts = entry.declaration.ownerPath.split(".");
+        for (let length = 1; length <= parts.length; length++) {
+            const owners = catalog.classes.get(fold(parts.slice(0, length).join(".")));
+            if (owners?.length !== 1 ||
+                owners[0].parseState !== "complete" ||
+                owners[0].file !== entry.file)
+                return false;
+        }
+        return true;
+    };
+    return facts.sites.map((site) => {
+        const result = (status, target = null, member = null) => ({ site, status, target, member });
+        if (site.blockedReason || facts.parseState !== "complete")
+            return result("blocked");
+        // A lexical first-segment binding must never fall through to an unrelated global suffix.
+        let candidates;
+        let lexicalOwner = site.lexicalOwner;
+        let scoped = false;
+        const first = site.typePath.split(".")[0];
+        while (lexicalOwner) {
+            const localPrefix = catalog.classes.get(fold(`${lexicalOwner}.${first}`));
+            if (localPrefix?.length) {
+                if (localPrefix.length !== 1 || localPrefix[0].parseState !== "complete")
+                    return result("ambiguous");
+                if (localPrefix[0].declaration.kind === "enum")
+                    return result("blocked");
+                candidates = catalog.classes.get(fold(`${lexicalOwner}.${site.typePath}`));
+                scoped = true;
+                break;
+            }
+            const own = catalog.classes.get(fold(lexicalOwner));
+            if (!own || own.length !== 1 || !uniqueOwner(own[0]) || own[0].file !== facts.file)
+                return result("blocked");
+            let ancestorOwner = own[0];
+            let ancestor = ancestorOwner.declaration.superclass;
+            const seen = new Set([fold(lexicalOwner)]);
+            while (ancestor) {
+                if (!qualifiedIdentifier.test(ancestor) || seen.has(fold(ancestor)) || seen.size >= 32)
+                    return result("blocked");
+                seen.add(fold(ancestor));
+                // A lexical superclass prefix also blocks global fallback, even if its suffix is absent.
+                let parentScope = ancestorOwner.declaration.ownerPath.split(".").slice(0, -1);
+                let parents;
+                let parentScoped = false;
+                while (parentScope.length) {
+                    const prefix = `${parentScope.join(".")}.${ancestor.split(".")[0]}`;
+                    if (catalog.classes.has(fold(prefix))) {
+                        parents = catalog.classes.get(fold(`${parentScope.join(".")}.${ancestor}`));
+                        parentScoped = true;
+                        break;
+                    }
+                    parentScope = parentScope.slice(0, -1);
+                }
+                if (!parentScoped) {
+                    // A nested class can inherit a type through an enclosing scope. Without a lexical
+                    // match, do not guess that an unqualified superclass names a global declaration.
+                    if (!ancestor.includes(".") && ancestorOwner.declaration.ownerPath.includes("."))
+                        return result("blocked");
+                    parents = catalog.classes.get(fold(ancestor));
+                }
+                if (!parents ||
+                    parents.length !== 1 ||
+                    parents[0].parseState !== "complete" ||
+                    !uniqueOwner(parents[0]) ||
+                    parents[0].declaration.kind !== "class")
+                    return result("blocked");
+                const ancestorPath = parents[0].declaration.ownerPath;
+                if (site.kind === "static_field_read" &&
+                    catalog.members.has(fold(`${ancestorPath}.${first}`)))
+                    return result("blocked");
+                const inheritedPrefix = catalog.classes.get(fold(`${ancestorPath}.${first}`));
+                if (inheritedPrefix?.length) {
+                    if (inheritedPrefix.length !== 1)
+                        return result("ambiguous");
+                    if (inheritedPrefix[0].declaration.kind === "enum")
+                        return result("blocked");
+                    candidates = catalog.classes.get(fold(`${ancestorPath}.${site.typePath}`));
+                    scoped = true;
+                    break;
+                }
+                ancestorOwner = parents[0];
+                ancestor = ancestorOwner.declaration.superclass;
+            }
+            if (scoped)
+                break;
+            lexicalOwner = lexicalOwner.includes(".")
+                ? lexicalOwner.slice(0, lexicalOwner.lastIndexOf("."))
+                : null;
+        }
+        if (!scoped)
+            candidates = catalog.classes.get(fold(site.typePath));
+        if (!candidates?.length)
+            return result("missing");
+        if (candidates.length !== 1)
+            return result("ambiguous");
+        const target = candidates[0];
+        if (target.parseState !== "complete" ||
+            !["class", "interface"].includes(target.declaration.kind))
+            return result("blocked");
+        if (target.declaration.kind === "interface" &&
+            (site.kind === "constructor" || site.kind === "static_field_read"))
+            return result("blocked");
+        // Every owning class must be unique too: nested declarations cannot bypass an outer collision.
+        if (!uniqueOwner(target))
+            return result("ambiguous");
+        if (!site.memberName)
+            return result("resolved", target);
+        const members = catalog.members.get(fold(`${target.declaration.ownerPath}.${site.memberName}`));
+        if (!members?.length)
+            return result("missing");
+        if (members.length !== 1)
+            return result("ambiguous");
+        if (!members[0].declaration.static ||
+            members[0].file !== target.file ||
+            members[0].parseState !== "complete")
+            return result("blocked");
+        return result("resolved", target, members[0]);
+    });
+}