@wrtnlabs/evidence 0.0.0

package/lib/adapters/swift/SwiftDocumentation.d.ts

@@ -0,0 +1,16 @@
+import type { IEvidenceDocumentation } from "../../structures/IEvidenceDocumentation";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { ISwiftDocumentation } from "./ISwiftDocumentation";
+/**
+ * Reads DocC while preserving source mappings and masking code examples.
+ *
+ * SwiftAdapter uses the normalized result for tag parsing after it establishes a documentation host.
+ */
+export declare namespace SwiftDocumentation {
+    /**
+     * Maps a classified carrier and removes ineligible example text without moving offsets.
+     *
+     * Preserved line positions let tag diagnostics map back to the original Swift source.
+     */
+    function read(source: IEvidenceSourceFile, documentation: ISwiftDocumentation, hostId: string): IEvidenceDocumentation;
+}

package/lib/adapters/swift/SwiftDocumentation.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwiftDocumentation = void 0;
+const EvidenceDocumentation_1 = require("../../parsers/EvidenceDocumentation");
+/**
+ * Reads DocC while preserving source mappings and masking code examples.
+ *
+ * SwiftAdapter uses the normalized result for tag parsing after it establishes a documentation host.
+ */
+var SwiftDocumentation;
+(function (SwiftDocumentation) {
+    /**
+     * Maps a classified carrier and removes ineligible example text without moving offsets.
+     *
+     * Preserved line positions let tag diagnostics map back to the original Swift source.
+     */
+    function read(source, documentation, hostId) {
+        const parsed = EvidenceDocumentation_1.EvidenceDocumentation.read(source.content, hostId, documentation.range, documentation.syntax);
+        if (!["/**", "///"].includes(documentation.syntax.opening))
+            return parsed;
+        return {
+            ...parsed,
+            text: mask(parsed.text),
+        };
+    }
+    SwiftDocumentation.read = read;
+    /**
+     * Masks HTML examples and Markdown indented code; shared tag parsing handles fences.
+     *
+     * Example text cannot accidentally create Evidence annotations.
+     */
+    function mask(input) {
+        const characters = input.split("");
+        const htmlCode = /<(pre|code)\b[^>]*>[\s\S]*?<\/\1\s*>/giu;
+        for (const match of input.matchAll(htmlCode))
+            hide(characters, match.index, match.index + match[0].length);
+        const lines = input.split("\n");
+        const indents = lines.filter((line) => line.trim() !== "").map(indentation);
+        const baseline = indents.reduce((minimum, indent) => Math.min(minimum, indent), Infinity);
+        let offset = 0;
+        for (const line of lines) {
+            if (indentation(line) >= baseline + 4)
+                hide(characters, offset, offset + line.length);
+            offset += line.length + 1;
+        }
+        return characters.join("");
+    }
+    /**
+     * Counts Markdown indentation after the documentation delimiter is removed.
+     *
+     * The value identifies code blocks relative to the least-indented prose line.
+     */
+    function indentation(line) {
+        let spaces = 0;
+        for (const character of line) {
+            if (character === " ")
+                ++spaces;
+            else if (character === "\t")
+                spaces += 4 - (spaces % 4);
+            else
+                break;
+        }
+        return spaces;
+    }
+    /**
+     * Replaces example characters with spaces while retaining original line boundaries.
+     *
+     * Keeping newlines intact preserves offsets for subsequent parsing and diagnostics.
+     */
+    function hide(characters, start, end) {
+        for (let index = start; index < end; ++index)
+            if (characters[index] !== "\n" && characters[index] !== "\r")
+                characters[index] = " ";
+    }
+})(SwiftDocumentation || (exports.SwiftDocumentation = SwiftDocumentation = {}));

package/lib/adapters/swift/SwiftFileScanner.d.ts

@@ -0,0 +1,87 @@
+import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { ISwiftFileAnalysis } from "./ISwiftFileAnalysis";
+/**
+ * Extracts lexical Swift source without compiler expansion or build-condition evaluation.
+ *
+ * Extensions and aliases are held apart from nominal declarations because their
+ * semantic ownership can resolve only after all selected files are available.
+ */
+export declare class SwiftFileScanner {
+    private readonly session;
+    private readonly source;
+    /**
+     * Node-free declarations retained after the parser callback.
+     *
+     * SwiftOwnership later reconciles them without extending the parse session lifetime.
+     */
+    private readonly declarations;
+    /**
+     * Documentation carriers indexed by their final original offset.
+     *
+     * Declaration scanning uses that offset to attach immediately preceding DocC.
+     */
+    private readonly documentation;
+    /**
+     * Unsupported syntax that prevents a complete denominator.
+     *
+     * These findings propagate to the inventory instead of allowing partial coverage to pass.
+     */
+    private readonly diagnostics;
+    /**
+     * Borrows the syntax tree only during the active parser callback.
+     *
+     * The source supplies durable file identity; node-free records preserve the
+     * ranges needed by later extension reconciliation and documentation hosts.
+     */
+    constructor(session: EvidenceParseSession, source: IEvidenceSourceFile);
+    /**
+     * Collects public source declarations and conservative semantic boundaries.
+     *
+     * Documentation is classified before traversal so a comment at an extension
+     * site remains attached even if its nominal target resolves in another file.
+     */
+    scan(): ISwiftFileAnalysis;
+    /**
+     * Visits declaration containers, never local function bodies or initializer expressions.
+     *
+     * The boundary prevents local implementation syntax from entering the public declaration inventory.
+     */
+    private walk;
+    /**
+     * Publishes source coordinates, ownership, and independently attached DocC.
+     *
+     * The record carries enough source facts for later ownership and host materialization.
+     */
+    private declare;
+    /**
+     * Ignores setter-only restrictions while respecting getter access and contextual defaults.
+     *
+     * The public surface follows readable-member visibility rather than setter mutability.
+     */
+    private visible;
+    /**
+     * Decodes backtick identifiers as literal accessor segments.
+     *
+     * The resulting name is used unchanged in semantic identities and public addresses.
+     */
+    private name;
+    /**
+     * Resolves only explicit, nongeneric nominal paths.
+     *
+     * Unsupported generic or qualified grammar shapes return no target for a visible diagnostic.
+     */
+    private path;
+    /**
+     * Groups adjacent DocC line comments while keeping unsupported carriers diagnosable.
+     *
+     * Tag-bearing non-DocC carriers remain records so the adapter can report their invalid placement.
+     */
+    private collectDocumentation;
+    /**
+     * Retains actionable failure instead of returning a smaller successful inventory.
+     *
+     * Every reported boundary marks the containing analysis incomplete.
+     */
+    private problem;
+}

package/lib/adapters/swift/SwiftFileScanner.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwiftFileScanner = void 0;
+const SourceText_1 = require("../../internal/SourceText");
+/**
+ * Extracts lexical Swift source without compiler expansion or build-condition evaluation.
+ *
+ * Extensions and aliases are held apart from nominal declarations because their
+ * semantic ownership can resolve only after all selected files are available.
+ */
+class SwiftFileScanner {
+    session;
+    source;
+    /**
+     * Node-free declarations retained after the parser callback.
+     *
+     * SwiftOwnership later reconciles them without extending the parse session lifetime.
+     */
+    declarations = [];
+    /**
+     * Documentation carriers indexed by their final original offset.
+     *
+     * Declaration scanning uses that offset to attach immediately preceding DocC.
+     */
+    documentation = new Map();
+    /**
+     * Unsupported syntax that prevents a complete denominator.
+     *
+     * These findings propagate to the inventory instead of allowing partial coverage to pass.
+     */
+    diagnostics = [];
+    /**
+     * Borrows the syntax tree only during the active parser callback.
+     *
+     * The source supplies durable file identity; node-free records preserve the
+     * ranges needed by later extension reconciliation and documentation hosts.
+     */
+    constructor(session, source) {
+        this.session = session;
+        this.source = source;
+    }
+    /**
+     * Collects public source declarations and conservative semantic boundaries.
+     *
+     * Documentation is classified before traversal so a comment at an extension
+     * site remains attached even if its nominal target resolves in another file.
+     */
+    scan() {
+        this.collectDocumentation();
+        for (const node of this.session.root.descendantsOfType([
+            "directive",
+            "macro_invocation",
+            "macro_declaration",
+        ]))
+            this.problem(node.type === "directive" ? "conditional-compilation" : "macro", "Swift compiler directives and macros require expansion or condition evaluation before the public surface can be established.", node);
+        this.walk(this.session.root, undefined, false);
+        return {
+            source: this.source,
+            declarations: this.declarations,
+            documentation: [...this.documentation.values()],
+            diagnostics: this.diagnostics,
+            complete: this.diagnostics.length === 0,
+        };
+    }
+    /**
+     * Visits declaration containers, never local function bodies or initializer expressions.
+     *
+     * The boundary prevents local implementation syntax from entering the public declaration inventory.
+     */
+    walk(container, owner, defaultPublic) {
+        for (const node of container.namedChildren) {
+            if (node.type === "class_declaration" ||
+                node.type === "protocol_declaration") {
+                const extension = node.children.some((child) => child.type === "extension");
+                const form = node.children.find((child) => [
+                    "class",
+                    "struct",
+                    "actor",
+                    "enum",
+                    "protocol",
+                    "extension",
+                ].includes(child.type))?.type ?? node.type;
+                const targetNode = node.childForFieldName("name");
+                const target = targetNode === null ? [] : this.path(targetNode);
+                const name = extension
+                    ? target.at(-1)
+                    : targetNode === null
+                        ? undefined
+                        : this.name(targetNode);
+                if (name === undefined) {
+                    this.problem("declaration-name", "The Swift type name could not be established.", node);
+                    continue;
+                }
+                const declaration = this.declare(node, owner, name, "type", extension || this.visible(node, defaultPublic), form, extension, extension ? target : undefined);
+                if (extension &&
+                    node.namedChildren.some((child) => child.type === "type_constraints"))
+                    this.problem("constrained-extension", "Constrained extensions require generic requirement resolution.", node);
+                const inheritance = node.namedChildren.filter((child) => child.type === "inheritance_specifier");
+                if (inheritance.length !== 0 &&
+                    (extension ||
+                        form === "enum" ||
+                        inheritance.some((child) => /\b(?:Codable|Encodable|Decodable|Equatable|Hashable|CaseIterable)\b/u.test(child.text))))
+                    this.problem("conformance-expansion", "Swift conformance or raw-value declarations require requirement visibility and synthesized-member resolution.", node);
+                const body = node.childForFieldName("body");
+                if (body !== null)
+                    this.walk(body, declaration, extension ? this.visible(node, false) : form === "protocol");
+            }
+            else if ([
+                "function_declaration",
+                "protocol_function_declaration",
+                "init_declaration",
+                "subscript_declaration",
+            ].includes(node.type)) {
+                const marker = node.children.findIndex((child) => child.type === "func");
+                const name = node.type === "init_declaration"
+                    ? "init"
+                    : node.type === "subscript_declaration"
+                        ? "subscript"
+                        : this.name(node.children[marker + 1] ?? node);
+                this.declare(node, owner, name, "function", this.visible(node, owner?.form === "enum" ? false : defaultPublic), node.type);
+            }
+            else if (["property_declaration", "protocol_property_declaration"].includes(node.type)) {
+                const patterns = node.namedChildren.filter((child) => child.type === "pattern");
+                const names = patterns
+                    .flatMap((pattern) => pattern.descendantsOfType("simple_identifier"))
+                    .map((name) => this.name(name));
+                if (names.length === 0 && this.visible(node, defaultPublic))
+                    this.problem("property-pattern", "The public Swift property binding could not be established.", node);
+                for (const name of names)
+                    this.declare(node, owner, name, "property", this.visible(node, owner?.form === "enum" ? false : defaultPublic), node.type);
+            }
+            else if (["typealias_declaration", "associatedtype_declaration"].includes(node.type)) {
+                const name = node.namedChildren.find((child) => child.type === "type_identifier");
+                if (name !== undefined) {
+                    const alias = node.type === "typealias_declaration";
+                    const target = node.namedChildren.find((child) => child.type === "user_type");
+                    this.declare(node, owner, this.name(name), "type", this.visible(node, owner?.form === "enum" ? false : defaultPublic), node.type, false, target === undefined ? undefined : this.path(target), alias);
+                }
+            }
+            else if (node.type === "enum_entry") {
+                for (const name of node.namedChildren.filter((child) => child.type === "simple_identifier"))
+                    this.declare(node, owner, this.name(name), "property", true, node.type);
+            }
+            else if (node.type.endsWith("_declaration") &&
+                ![
+                    "import_declaration",
+                    "deinit_declaration",
+                    "operator_declaration",
+                    "precedence_group_declaration",
+                    "macro_declaration",
+                ].includes(node.type))
+                this.problem("unsupported-declaration", `Swift declaration '${node.type}' needs extraction support.`, node);
+        }
+    }
+    /**
+     * Publishes source coordinates, ownership, and independently attached DocC.
+     *
+     * The record carries enough source facts for later ownership and host materialization.
+     */
+    declare(node, owner, name, symbol, visible, form, extension = false, target, alias = false) {
+        const modifiers = node.namedChildren.find((child) => child.type === "modifiers");
+        const staticMember = owner !== undefined &&
+            (modifiers === undefined ? [] : modifiers.namedChildren).some((child) => ["static", "class"].includes(child.text)) === true;
+        const address = extension
+            ? (target ?? [])
+            : [...(owner?.address ?? []), ...(staticMember ? ["static"] : []), name];
+        const siteId = `swift:${this.source.id}:site:${node.startIndex}:${node.endIndex}`;
+        const range = this.session.range(node);
+        const declaration = {
+            id: `${siteId}:${symbol}:${name}`,
+            name,
+            symbol,
+            address,
+            identity: address,
+            public: owner?.public !== false && visible,
+            extension,
+            alias,
+            form,
+            filePrivate: (owner?.filePrivate === true &&
+                (owner.form !== "extension" || !visible)) ||
+                (modifiers === undefined ? [] : modifiers.namedChildren).some((child) => child.type === "visibility_modifier" &&
+                    ["private", "fileprivate"].includes(child.text)) === true,
+            ...(target === undefined ? {} : { target }),
+            ...(owner === undefined ? {} : { ownerDeclarationId: owner.id }),
+            site: {
+                id: siteId,
+                file: this.source.physicalPath,
+                range,
+                content: [range],
+            },
+        };
+        this.declarations.push(declaration);
+        const previous = node.previousNamedSibling;
+        if (previous !== null &&
+            /^\s*$/u.test(this.source.content.slice(previous.endIndex, node.startIndex))) {
+            const documentation = this.documentation.get(previous.endIndex);
+            if (documentation !== undefined &&
+                ["///", "/**"].includes(documentation.syntax.opening))
+                documentation.attachments.push({
+                    declarationId: declaration.id,
+                    siteId,
+                });
+        }
+        for (const attribute of (modifiers === undefined
+            ? []
+            : modifiers.namedChildren).filter((child) => child.type === "attribute")) {
+            const attributeName = attribute.namedChildren[0]?.text;
+            if (![
+                "available",
+                "inlinable",
+                "usableFromInline",
+                "discardableResult",
+                "escaping",
+                "autoclosure",
+                "Sendable",
+                "MainActor",
+                "objc",
+                "objcMembers",
+                "nonobjc",
+                "preconcurrency",
+                "backDeployed",
+            ].includes(attributeName ?? ""))
+                this.problem("attribute-expansion", `Swift attribute '${attributeName ?? attribute.text}' may generate or alter declarations; implement its semantics before checking coverage.`, attribute);
+        }
+        return declaration;
+    }
+    /**
+     * Ignores setter-only restrictions while respecting getter access and contextual defaults.
+     *
+     * The public surface follows readable-member visibility rather than setter mutability.
+     */
+    visible(node, fallback) {
+        const modifiers = node.namedChildren.find((child) => child.type === "modifiers");
+        const visibility = (modifiers === undefined ? [] : modifiers.namedChildren).find((child) => child.type === "visibility_modifier" && !child.text.includes("("));
+        return visibility === undefined
+            ? fallback
+            : ["public", "open"].includes(visibility.text);
+    }
+    /**
+     * Decodes backtick identifiers as literal accessor segments.
+     *
+     * The resulting name is used unchanged in semantic identities and public addresses.
+     */
+    name(node) {
+        return node.text.startsWith("`") ? node.text.slice(1, -1) : node.text;
+    }
+    /**
+     * Resolves only explicit, nongeneric nominal paths.
+     *
+     * Unsupported generic or qualified grammar shapes return no target for a visible diagnostic.
+     */
+    path(node) {
+        if (node.type === "type_identifier")
+            return [this.name(node)];
+        if (node.type !== "user_type" ||
+            node.namedChildren.some((child) => child.type !== "type_identifier"))
+            return [];
+        return node.namedChildren.map((child) => this.name(child));
+    }
+    /**
+     * Groups adjacent DocC line comments while keeping unsupported carriers diagnosable.
+     *
+     * Tag-bearing non-DocC carriers remain records so the adapter can report their invalid placement.
+     */
+    collectDocumentation() {
+        const nodes = this.session.root.descendantsOfType([
+            "comment",
+            "multiline_comment",
+            "line_string_literal",
+            "multi_line_string_literal",
+        ]);
+        const text = new SourceText_1.SourceText(this.source.content);
+        let previous;
+        for (const node of nodes) {
+            const line = node.type === "comment";
+            const block = node.type === "multiline_comment";
+            const doc = (line && node.text.startsWith("///")) ||
+                (block && node.text.startsWith("/**"));
+            if (!doc &&
+                !/@(?:evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link|internal|hidden|ignore)\b/u.test(node.text)) {
+                previous = undefined;
+                continue;
+            }
+            if (line &&
+                doc &&
+                previous?.syntax?.opening === "///" &&
+                /^[ \t]*\r?\n[ \t]*$/u.test(this.source.content.slice(previous.range.end.offset, node.startIndex))) {
+                this.documentation.delete(previous.range.end.offset);
+                previous.range = text.range(previous.range.start.offset, node.endIndex);
+                this.documentation.set(node.endIndex, previous);
+                continue;
+            }
+            const opening = line
+                ? doc
+                    ? "///"
+                    : "//"
+                : block
+                    ? doc
+                        ? "/**"
+                        : "/*"
+                    : node.text.startsWith('"""')
+                        ? '"""'
+                        : '"';
+            previous = {
+                id: `swift:${this.source.id}:documentation:${node.startIndex}`,
+                range: this.session.range(node),
+                syntax: {
+                    opening,
+                    closing: line ? "" : block ? "*/" : opening,
+                    ...(line
+                        ? { linePrefix: opening }
+                        : block
+                            ? { linePrefix: "*" }
+                            : {}),
+                    tagBoundaries: true,
+                    allowWithdrawal: doc,
+                },
+                attachments: [],
+            };
+            this.documentation.set(node.endIndex, previous);
+        }
+    }
+    /**
+     * Retains actionable failure instead of returning a smaller successful inventory.
+     *
+     * Every reported boundary marks the containing analysis incomplete.
+     */
+    problem(code, message, node) {
+        this.diagnostics.push({
+            code: `swift-${code}`,
+            severity: "error",
+            message,
+            repair: "Select supported explicit Swift source or implement the reported semantic boundary before evaluating coverage.",
+            location: {
+                file: this.source.physicalPath,
+                range: this.session.range(node),
+            },
+        });
+    }
+}
+exports.SwiftFileScanner = SwiftFileScanner;

package/lib/adapters/swift/SwiftOwnership.d.ts

@@ -0,0 +1,16 @@
+import type { ISwiftFileAnalysis } from "./ISwiftFileAnalysis";
+/**
+ * Reconciles extensions against nominal declarations in one configured Swift module.
+ *
+ * The pass resolves selected local aliases without importing compiler metadata,
+ * then propagates visibility from the verified nominal owner to extension members.
+ */
+export declare namespace SwiftOwnership {
+    /**
+     * Resolves local aliases and extension-introduced types before propagating visibility.
+     *
+     * Repeated passes handle declarations whose owner is another pending extension;
+     * unresolved cycles remain incomplete instead of gaining an invented owner.
+     */
+    function resolve(analyses: ISwiftFileAnalysis[]): void;
+}

package/lib/adapters/swift/SwiftOwnership.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwiftOwnership = void 0;
+/**
+ * Reconciles extensions against nominal declarations in one configured Swift module.
+ *
+ * The pass resolves selected local aliases without importing compiler metadata,
+ * then propagates visibility from the verified nominal owner to extension members.
+ */
+var SwiftOwnership;
+(function (SwiftOwnership) {
+    /**
+     * Resolves local aliases and extension-introduced types before propagating visibility.
+     *
+     * Repeated passes handle declarations whose owner is another pending extension;
+     * unresolved cycles remain incomplete instead of gaining an invented owner.
+     */
+    function resolve(analyses) {
+        const declarations = analyses.flatMap((analysis) => analysis.declarations);
+        const ids = new Map(declarations.map((declaration) => [declaration.id, declaration]));
+        const pending = new Set(declarations.filter((declaration) => declaration.extension));
+        let progress = true;
+        while (progress && pending.size !== 0) {
+            progress = false;
+            const types = new Map();
+            for (const declaration of declarations)
+                if (declaration.symbol === "type" &&
+                    !declaration.extension &&
+                    ![...pending].some((extension) => descends(declaration, extension.id, ids))) {
+                    const key = JSON.stringify(declaration.identity);
+                    types.set(key, [...(types.get(key) ?? []), declaration]);
+                }
+            for (const declaration of pending) {
+                const target = nominal(declaration.target ?? [], types, declaration.site.file, new Set());
+                if (target === undefined)
+                    continue;
+                const old = declaration.address;
+                declaration.address = [...target.address];
+                declaration.identity = [...target.identity];
+                declaration.name = target.name;
+                declaration.public = target.public;
+                if (target.ownerDeclarationId === undefined)
+                    delete declaration.ownerDeclarationId;
+                else
+                    declaration.ownerDeclarationId = target.ownerDeclarationId;
+                for (const child of declarations)
+                    if (descends(child, declaration.id, ids)) {
+                        child.address = [
+                            ...target.address,
+                            ...child.address.slice(old.length),
+                        ];
+                        child.identity = [...child.address];
+                    }
+                pending.delete(declaration);
+                progress = true;
+            }
+        }
+        for (const declaration of pending) {
+            declaration.public = false;
+            const analysis = analyses.find((entry) => entry.source.physicalPath === declaration.site.file);
+            if (analysis === undefined)
+                continue;
+            analysis.complete = false;
+            analysis.diagnostics.push({
+                code: "swift-extension-ownership",
+                severity: "error",
+                message: `Extension '${declaration.address.join(".")}' requires one accessible selected local nominal type; external, ambiguous, cyclic, and generic ownership is unavailable.`,
+                repair: "Include the accessible local nominal owner in the configured Swift module or implement external type ownership before checking coverage.",
+                location: {
+                    file: analysis.source.physicalPath,
+                    range: declaration.site.range,
+                },
+            });
+        }
+        for (const declaration of declarations)
+            declaration.public &&= visible(declaration, ids, new Set());
+    }
+    SwiftOwnership.resolve = resolve;
+    /**
+     * Resolves a unique accessible declaration and a finite chain of selected type aliases.
+     *
+     * A visited path set rejects cycles before they can grant an extension an invented owner.
+     */
+    function nominal(path, types, file, visited) {
+        const key = JSON.stringify(path);
+        if (visited.has(key))
+            return undefined;
+        visited.add(key);
+        const accessible = (types.get(key) ?? []).filter((declaration) => !declaration.filePrivate || declaration.site.file === file);
+        const local = accessible.filter((declaration) => declaration.filePrivate && declaration.site.file === file);
+        const matches = local.length !== 0 ? local : accessible;
+        if (matches.length !== 1)
+            return undefined;
+        const declaration = matches[0];
+        if (declaration === undefined)
+            return undefined;
+        if (!declaration.alias)
+            return ["class", "struct", "actor", "enum", "protocol"].includes(declaration.form)
+                ? declaration
+                : undefined;
+        if (declaration.target === undefined)
+            return undefined;
+        const scope = declaration.identity.slice(0, -1);
+        for (let length = scope.length; length >= 0; --length) {
+            const resolved = nominal([...scope.slice(0, length), ...declaration.target], types, declaration.site.file, new Set(visited));
+            if (resolved !== undefined)
+                return resolved;
+        }
+        return undefined;
+    }
+    /**
+     * Uses explicit declaration parents to distinguish literal names from containment.
+     *
+     * This preserves names that contain punctuation without interpreting them as paths.
+     */
+    function descends(declaration, parentId, ids) {
+        let owner = declaration.ownerDeclarationId;
+        const visited = new Set();
+        while (owner !== undefined && !visited.has(owner)) {
+            if (owner === parentId)
+                return true;
+            visited.add(owner);
+            owner = ids.get(owner)?.ownerDeclarationId;
+        }
+        return false;
+    }
+    /**
+     * Clamps descendant exposure to the effective public owner.
+     *
+     * Recursive ownership also rejects a malformed parent cycle from the published surface.
+     */
+    function visible(declaration, ids, visited) {
+        if (!declaration.public || visited.has(declaration.id))
+            return false;
+        visited.add(declaration.id);
+        const owner = declaration.ownerDeclarationId === undefined
+            ? undefined
+            : ids.get(declaration.ownerDeclarationId);
+        return owner === undefined || visible(owner, ids, visited);
+    }
+})(SwiftOwnership || (exports.SwiftOwnership = SwiftOwnership = {}));