@haystackeditor/cli 0.25.1 → 0.26.0

package/dist/commands/cloud-verifier-python-manifest-selector-census.js

@@ -1,2015 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFileSync, statSync } from 'node:fs';
-import { basename, dirname, extname, join, posix } from 'node:path';
-const MAX_SOURCE_BYTES = 4 * 1024 * 1024;
-const PYTHON_EXTENSIONS = new Set(['.py', '.pyi']);
-const TEST_COMPONENTS = new Set([
-    '__fixtures__', '__tests__', 'benchmark', 'benchmarks', 'example', 'examples',
-    'fixture', 'fixtures', 'mock', 'mocks', 'sample', 'samples', 'spec', 'specs',
-    'test', 'testapp', 'testapps', 'tests',
-]);
-const STRUCTURED_DEPENDENCY_COMPONENTS = new Set([
-    '.eggs', 'dist-packages', 'node_modules', 'site-packages', '__pypackages__',
-]);
-const NEGATIVE_PIPELINE_PARTS = new Set([
-    'complete', 'completion', 'completions', 'exhaustive', 'exhaustiveness',
-    'rank', 'ranking', 'search', 'sort', 'sorted', 'validate', 'validation',
-]);
-const MANIFEST_NAMESPACE_KEYS = ['namespace', 'id', 'subdir', 'python', 'name'];
-function sha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function stableId(kind, identityKey) {
-    const slug = kind.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    return `census-${slug}-${sha256(`${kind}\0${identityKey}`).slice(0, 20)}`;
-}
-function recordStableId(kind, path, owner, identity) {
-    return stableId(kind, `${path}#${owner}:${identity}`);
-}
-function normalizePath(value) {
-    return value.replaceAll('\\', '/').replace(/^\.\//, '').replace(/\/{2,}/g, '/');
-}
-function pathComponents(path) {
-    return normalizePath(path).toLowerCase().split('/');
-}
-function isTestPath(path) {
-    const components = pathComponents(path);
-    const name = basename(path).toLowerCase();
-    return components.slice(0, -1).some((component) => TEST_COMPONENTS.has(component))
-        || /(?:^|[._-])(test|tests|spec|fixture|mock)(?:[._-]|$)/.test(name)
-        || /^(?:test_|conftest\.)/.test(name);
-}
-function isDependencyPath(path) {
-    const components = pathComponents(path);
-    return components.slice(0, -1).some((component) => STRUCTURED_DEPENDENCY_COMPONENTS.has(component))
-        || components.some((component) => /\.(?:dist|egg)-info$/.test(component));
-}
-function structuredDependencyPackagePrefixes(paths, sources) {
-    const versionedPackagesByContainer = new Map();
-    const projectManifestNames = new Set(['pyproject.toml', 'setup.cfg', 'setup.py']);
-    for (const path of paths) {
-        if (basename(path).toLowerCase() !== '__init__.py')
-            continue;
-        const source = sources.get(path);
-        if (!source)
-            continue;
-        const hasVersionDeclaration = pythonStatements(path, source).some((statement) => /^(?:from\s+\.[A-Za-z_][A-Za-z0-9_.]*\s+import\s+.*(?:\bVERSION\b|__version__)|(?:VERSION|__version__)\s*=)/.test(statement.text));
-        if (!hasVersionDeclaration)
-            continue;
-        const packageRoot = dirname(path);
-        if (paths.some((candidate) => dirname(candidate) === packageRoot
-            && projectManifestNames.has(basename(candidate).toLowerCase())))
-            continue;
-        const container = dirname(packageRoot);
-        if (sources.has(`${container}/__init__.py`))
-            continue;
-        const packages = versionedPackagesByContainer.get(container) ?? new Set();
-        packages.add(packageRoot);
-        versionedPackagesByContainer.set(container, packages);
-    }
-    const result = new Set();
-    for (const packages of versionedPackagesByContainer.values()) {
-        // Several independently versioned, manifest-free packages under an
-        // unversioned container form a structured bundled-distribution boundary.
-        if (packages.size < 3)
-            continue;
-        packages.forEach((packageRoot) => result.add(packageRoot));
-    }
-    return result;
-}
-function isStructuredDependencyPath(path, prefixes) {
-    return isDependencyPath(path)
-        || [...prefixes].some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
-}
-function readText(root, path) {
-    try {
-        const absolute = join(root, path);
-        const stat = statSync(absolute);
-        if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES)
-            return null;
-        const bytes = readFileSync(absolute);
-        if (bytes.includes(0))
-            return null;
-        return bytes.toString('utf8');
-    }
-    catch {
-        return null;
-    }
-}
-function indentation(line) {
-    const prefix = line.match(/^\s*/)?.[0] ?? '';
-    return [...prefix].reduce((total, char) => total + (char === '\t' ? 8 : 1), 0);
-}
-function stripPythonComment(value) {
-    let quote = null;
-    let triple = false;
-    let escaped = false;
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (char === '\\') {
-            escaped = true;
-            continue;
-        }
-        if (quote) {
-            if (triple && value.slice(index, index + 3) === quote.repeat(3)) {
-                index += 2;
-                quote = null;
-                triple = false;
-            }
-            else if (!triple && char === quote) {
-                quote = null;
-            }
-            continue;
-        }
-        if ((char === "'" || char === '"') && value.slice(index, index + 3) === char.repeat(3)) {
-            quote = char;
-            triple = true;
-            index += 2;
-            continue;
-        }
-        if (char === "'" || char === '"') {
-            quote = char;
-            continue;
-        }
-        if (char === '#')
-            return value.slice(0, index);
-    }
-    return value;
-}
-function bracketDelta(value) {
-    let result = 0;
-    let quote = null;
-    let escaped = false;
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (char === '\\') {
-            escaped = true;
-            continue;
-        }
-        if (quote) {
-            if (char === quote)
-                quote = null;
-            continue;
-        }
-        if (char === "'" || char === '"') {
-            quote = char;
-            continue;
-        }
-        if (char === '(' || char === '[' || char === '{')
-            result += 1;
-        if (char === ')' || char === ']' || char === '}')
-            result -= 1;
-    }
-    return result;
-}
-function canonicalExpression(value) {
-    let result = '';
-    let quote = null;
-    let escaped = false;
-    for (const char of value.trim()) {
-        if (escaped) {
-            result += char;
-            escaped = false;
-            continue;
-        }
-        if (char === '\\') {
-            result += char;
-            escaped = true;
-            continue;
-        }
-        if (quote) {
-            result += char;
-            if (char === quote)
-                quote = null;
-            continue;
-        }
-        if (char === "'" || char === '"') {
-            quote = char;
-            result += char;
-            continue;
-        }
-        if (!/\s/.test(char))
-            result += char;
-    }
-    return result.replace(/;$/, '');
-}
-function maskMultilinePythonStrings(lines) {
-    let triple = null;
-    return lines.map((line) => {
-        let result = '';
-        let quote = null;
-        let escapedCharacter = false;
-        for (let index = 0; index < line.length; index += 1) {
-            if (triple) {
-                const close = line.indexOf(triple, index);
-                if (close < 0)
-                    break;
-                index = close + 2;
-                triple = null;
-                continue;
-            }
-            const char = line[index];
-            if (escapedCharacter) {
-                result += char;
-                escapedCharacter = false;
-                continue;
-            }
-            if (char === '\\') {
-                result += char;
-                escapedCharacter = true;
-                continue;
-            }
-            if (quote) {
-                result += char;
-                if (char === quote)
-                    quote = null;
-                continue;
-            }
-            if ((char === "'" || char === '"') && line.slice(index, index + 3) === char.repeat(3)) {
-                triple = char.repeat(3);
-                result += char.repeat(2);
-                index += 2;
-                continue;
-            }
-            if (char === "'" || char === '"')
-                quote = char;
-            result += char;
-        }
-        return result;
-    });
-}
-function pythonStatements(path, source) {
-    const originalLines = source.split(/\r?\n/);
-    const lines = maskMultilinePythonStrings(originalLines);
-    const statements = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const start = index;
-        const pieces = [];
-        let depth = 0;
-        do {
-            const withoutComment = stripPythonComment(lines[index]);
-            pieces.push(withoutComment.trim());
-            depth += bracketDelta(withoutComment);
-            if (depth <= 0 && !withoutComment.trimEnd().endsWith('\\'))
-                break;
-            index += 1;
-        } while (index < lines.length && index - start < 10_000);
-        const text = pieces.filter(Boolean).join(' ').replace(/\\\s+/g, ' ').trim();
-        if (!text)
-            continue;
-        statements.push({
-            path,
-            startLine: start + 1,
-            endLine: index + 1,
-            indent: indentation(lines[start]),
-            text,
-            anchor: originalLines[start],
-            owner: basename(path),
-            scope: 'module',
-        });
-    }
-    const owners = [];
-    for (const statement of statements) {
-        while (owners.length > 0 && statement.indent <= owners.at(-1).indent)
-            owners.pop();
-        const declaration = statement.text.match(/^(?:async\s+def|def|class)\s+([A-Za-z_][A-Za-z0-9_]*)\b/);
-        if (declaration)
-            owners.push({
-                indent: statement.indent,
-                name: declaration[1],
-                scope: /^class\s/.test(statement.text) ? 'class' : 'function',
-            });
-        statement.owner = owners.length > 0
-            ? owners.map((owner) => owner.name).join('.')
-            : basename(path);
-        statement.scope = owners.at(-1)?.scope ?? 'module';
-    }
-    return statements;
-}
-function splitTopLevel(value, delimiter) {
-    const result = [];
-    let start = 0;
-    let depth = 0;
-    let quote = null;
-    let escaped = false;
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (char === '\\') {
-            escaped = true;
-            continue;
-        }
-        if (quote) {
-            if (char === quote)
-                quote = null;
-            continue;
-        }
-        if (char === "'" || char === '"') {
-            quote = char;
-            continue;
-        }
-        if (char === '(' || char === '[' || char === '{')
-            depth += 1;
-        if (char === ')' || char === ']' || char === '}')
-            depth -= 1;
-        if (depth === 0 && value.slice(index, index + delimiter.length) === delimiter) {
-            result.push(value.slice(start, index).trim());
-            start = index + delimiter.length;
-            index += delimiter.length - 1;
-        }
-    }
-    result.push(value.slice(start).trim());
-    return result;
-}
-function topLevelIndex(value, sought) {
-    let depth = 0;
-    let quote = null;
-    let escaped = false;
-    for (let index = 0; index <= value.length - sought.length; index += 1) {
-        const char = value[index];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (char === '\\') {
-            escaped = true;
-            continue;
-        }
-        if (quote) {
-            if (char === quote)
-                quote = null;
-            continue;
-        }
-        if (char === "'" || char === '"') {
-            quote = char;
-            continue;
-        }
-        if (char === '(' || char === '[' || char === '{')
-            depth += 1;
-        if (char === ')' || char === ']' || char === '}')
-            depth -= 1;
-        if (depth === 0 && value.slice(index, index + sought.length) === sought)
-            return index;
-    }
-    return -1;
-}
-function decodePythonLiteral(value) {
-    const trimmed = value.trim();
-    if (/^[+-]?(?:0|[1-9][0-9]*)$/.test(trimmed)) {
-        try {
-            return `number:${BigInt(trimmed).toString()}`;
-        }
-        catch {
-            return null;
-        }
-    }
-    if (/^[+-]?(?:(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+))$/.test(trimmed)
-        || /^[+-]?[0-9]+\.[0-9]*$/.test(trimmed)) {
-        const number = Number(trimmed);
-        return Number.isFinite(number) ? `number:${Object.is(number, -0) ? '0' : String(number)}` : null;
-    }
-    if (trimmed === 'True')
-        return 'boolean:true';
-    if (trimmed === 'False')
-        return 'boolean:false';
-    if (trimmed === 'None')
-        return 'null:null';
-    const string = trimmed.match(/^(?:[rRuU]{0,2})?(['"])([\s\S]*)\1$/);
-    if (!string)
-        return null;
-    const body = string[2];
-    const decoded = body.replace(/\\(['"\\nrt])/g, (_match, escaped) => {
-        if (escaped === 'n')
-            return '\n';
-        if (escaped === 'r')
-            return '\r';
-        if (escaped === 't')
-            return '\t';
-        return escaped;
-    });
-    return `string:${JSON.stringify(decoded)}`;
-}
-function canonicalSelectorExpression(value) {
-    const literal = decodePythonLiteral(value);
-    if (literal !== null)
-        return literal;
-    const canonical = canonicalExpression(value);
-    const components = canonical.split('.');
-    const final = components.at(-1) ?? '';
-    return /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(canonical)
-        && /^[A-Z_][A-Z0-9_]*$/.test(final)
-        ? `expression:${canonical}`
-        : null;
-}
-function exactSubject(value) {
-    const canonical = canonicalExpression(value);
-    return /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*|\[(?:['"][^'"]+['"]|-?[0-9]+)\])*$/.test(canonical)
-        ? canonical
-        : null;
-}
-function equalityCondition(value) {
-    const operator = topLevelIndex(value, '==');
-    if (operator < 0 || topLevelIndex(value.slice(operator + 2), '==') >= 0)
-        return null;
-    const left = value.slice(0, operator).trim();
-    const right = value.slice(operator + 2).trim();
-    const leftLiteral = decodePythonLiteral(left);
-    const rightLiteral = decodePythonLiteral(right);
-    const leftSubject = exactSubject(left);
-    const rightSubject = exactSubject(right);
-    if (leftSubject && rightLiteral !== null)
-        return { subject: leftSubject, selector: rightLiteral };
-    if (rightSubject && leftLiteral !== null)
-        return { subject: rightSubject, selector: leftLiteral };
-    return null;
-}
-function branchHeader(statement) {
-    const match = statement.text.match(/^(if|elif|else)\b\s*(.*)$/);
-    if (!match)
-        return null;
-    const colon = topLevelIndex(match[2], ':');
-    if (colon < 0)
-        return null;
-    return {
-        keyword: match[1],
-        condition: match[1] === 'else' ? '' : match[2].slice(0, colon).trim(),
-        inlineSuite: match[2].slice(colon + 1).trim(),
-    };
-}
-function terminalIdentity(value) {
-    const parts = splitTopLevel(value, ';').filter(Boolean);
-    const terminal = parts.at(-1)?.trim() ?? '';
-    const control = terminal.match(/^(return|raise|yield)\s+(.+)$/);
-    if (control)
-        return `${control[1]}:${canonicalExpression(control[2])}`;
-    const assignment = terminal.match(/^([A-Za-z_][A-Za-z0-9_.]*(?:\[[^\]]+\])?)\s*=\s*(.+)$/);
-    if (assignment)
-        return `assign:${canonicalExpression(assignment[1])}:${canonicalExpression(assignment[2])}`;
-    if (/^(?:await\s+)?[A-Za-z_][A-Za-z0-9_.]*\s*\(/.test(terminal)) {
-        return `call:${canonicalExpression(terminal)}`;
-    }
-    return null;
-}
-function emitEqualityChains(statements, records) {
-    for (let index = 0; index < statements.length; index += 1) {
-        const first = branchHeader(statements[index]);
-        if (!first || first.keyword !== 'if')
-            continue;
-        const equality = equalityCondition(first.condition);
-        if (!equality)
-            continue;
-        const branches = [];
-        let cursor = index;
-        let expectedSubject = equality.subject;
-        while (cursor < statements.length) {
-            const statement = statements[cursor];
-            const header = branchHeader(statement);
-            if (!header || (header.keyword !== 'if' && header.keyword !== 'elif'))
-                break;
-            const parsed = equalityCondition(header.condition);
-            if (!parsed || parsed.subject !== expectedSubject)
-                break;
-            let nextPeer = cursor + 1;
-            while (nextPeer < statements.length && statements[nextPeer].indent > statement.indent)
-                nextPeer += 1;
-            const suiteStatements = statements.slice(cursor + 1, nextPeer);
-            const implementation = header.inlineSuite
-                ? terminalIdentity(header.inlineSuite)
-                : [...suiteStatements].reverse().map((candidate) => terminalIdentity(candidate.text)).find(Boolean) ?? null;
-            if (!implementation)
-                break;
-            branches.push({ statement, selector: parsed.selector, implementation });
-            if (nextPeer >= statements.length) {
-                cursor = nextPeer;
-                break;
-            }
-            const nextHeader = branchHeader(statements[nextPeer]);
-            if (statements[nextPeer].indent !== statement.indent
-                || statements[nextPeer].owner !== statement.owner
-                || nextHeader?.keyword !== 'elif') {
-                cursor = nextPeer;
-                break;
-            }
-            cursor = nextPeer;
-            expectedSubject = parsed.subject;
-        }
-        if (branches.length < 3
-            || new Set(branches.map((branch) => branch.selector)).size !== branches.length
-            || new Set(branches.map((branch) => branch.implementation)).size !== branches.length)
-            continue;
-        const statement = statements[index];
-        const ownerIdentity = `${statement.path}#${statement.owner}`;
-        const signature = sha256(branches.map((branch) => `${branch.selector}\0${branch.implementation}`).join('\0')).slice(0, 24);
-        const identity = `python-equality:${equality.subject}:${signature}`;
-        const familyKind = 'python-exact-equality-selector-family';
-        const entryKind = 'python-exact-equality-selector-entry';
-        const familyId = recordStableId(familyKind, statement.path, statement.owner, identity);
-        records.push({
-            kind: familyKind,
-            projections: ['registry_families'],
-            presumptiveInventory: true,
-            proofStatus: 'proof-complete',
-            path: statement.path,
-            line: statement.startLine,
-            anchor: statement.anchor,
-            owner: statement.owner,
-            identity,
-            tokens: [equality.subject, 'proof-complete:python-exact-equality-chain'],
-            semanticIdentityKey: `python-registry-family\0${ownerIdentity}\0equality\0${equality.subject}\0${signature}`,
-            identityComponents: {
-                identity_kind: 'python-registry-family',
-                owner_identity: ownerIdentity,
-                selector_domain: equality.subject,
-            },
-        });
-        branches.forEach((branch) => {
-            const entryIdentity = `${identity}:selector:${branch.selector}:implementation:${branch.implementation}`;
-            records.push({
-                kind: entryKind,
-                projections: ['registry_entries'],
-                presumptiveInventory: true,
-                proofStatus: 'proof-complete',
-                path: branch.statement.path,
-                line: branch.statement.startLine,
-                anchor: branch.statement.anchor,
-                owner: branch.statement.owner,
-                identity: entryIdentity,
-                tokens: [branch.selector, branch.implementation, 'proof-complete:python-exact-equality-chain'],
-                selectorKey: branch.selector,
-                implementationKey: `${ownerIdentity}:${branch.implementation}`,
-                selectorFamilyRecordId: familyId,
-                semanticIdentityKey: `python-registry-entry\0${ownerIdentity}\0equality\0${equality.subject}\0${branch.selector}\0${branch.implementation}`,
-                identityComponents: {
-                    identity_kind: 'python-registry-entry',
-                    owner_identity: ownerIdentity,
-                    selector_domain: equality.subject,
-                    selector_key: branch.selector,
-                    implementation_identity: `${ownerIdentity}:${branch.implementation}`,
-                },
-            });
-        });
-        index = Math.max(index, cursor - 1);
-    }
-}
-function unwrapCollection(value, open, close) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith(open) || !trimmed.endsWith(close))
-        return null;
-    return trimmed.slice(open.length, -close.length).trim();
-}
-function parseStaticCollections(statements) {
-    const collections = new Map();
-    for (const statement of statements) {
-        const assignment = statement.text.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*(?::[^=]+)?=\s*([\s\S]+)$/);
-        if (!assignment)
-            continue;
-        const symbol = assignment[1];
-        if (symbol === '__all__')
-            continue;
-        const expression = assignment[2].trim();
-        const dictBody = unwrapCollection(expression, '{', '}');
-        if (dictBody !== null && !/^\s*$/.test(dictBody)) {
-            const entries = [];
-            let valid = true;
-            for (const rawEntry of splitTopLevel(dictBody, ',')) {
-                if (!rawEntry)
-                    continue;
-                const colon = topLevelIndex(rawEntry, ':');
-                if (colon < 0 || rawEntry.trimStart().startsWith('**')) {
-                    valid = false;
-                    break;
-                }
-                const selector = canonicalSelectorExpression(rawEntry.slice(0, colon));
-                const implementation = rawEntry.slice(colon + 1).trim();
-                if (selector === null || !implementation || /\bfor\b/.test(implementation)) {
-                    valid = false;
-                    break;
-                }
-                entries.push({
-                    selector,
-                    implementation: canonicalExpression(implementation),
-                    line: statement.startLine,
-                    anchor: statement.anchor,
-                });
-            }
-            if (valid && entries.length > 0 && new Set(entries.map((entry) => entry.selector)).size === entries.length) {
-                const collection = {
-                    collectionKind: 'mapping', path: statement.path, symbol, owner: statement.owner,
-                    line: statement.startLine, anchor: statement.anchor,
-                    ephemeral: statement.scope === 'function',
-                    entries,
-                };
-                collections.set(statement.scope === 'module' ? symbol : `${statement.owner}.${symbol}`, collection);
-            }
-            continue;
-        }
-        const listBody = unwrapCollection(expression, '[', ']') ?? unwrapCollection(expression, '(', ')');
-        if (listBody === null || !listBody)
-            continue;
-        const entries = [];
-        let valid = true;
-        for (const rawItem of splitTopLevel(listBody, ',')) {
-            if (!rawItem)
-                continue;
-            const tupleBody = unwrapCollection(rawItem, '(', ')');
-            if (tupleBody !== null) {
-                const tuple = splitTopLevel(tupleBody, ',').filter(Boolean);
-                const selector = tuple.length === 2 ? canonicalSelectorExpression(tuple[0]) : null;
-                if (selector === null || !tuple[1]) {
-                    valid = false;
-                    break;
-                }
-                entries.push({
-                    selector,
-                    implementation: canonicalExpression(tuple[1]),
-                    line: statement.startLine,
-                    anchor: statement.anchor,
-                });
-            }
-            else {
-                const selector = canonicalSelectorExpression(rawItem);
-                if (selector === null) {
-                    valid = false;
-                    break;
-                }
-                entries.push({
-                    selector,
-                    implementation: '$selector',
-                    line: statement.startLine,
-                    anchor: statement.anchor,
-                });
-            }
-        }
-        if (valid && entries.length > 0 && new Set(entries.map((entry) => entry.selector)).size === entries.length) {
-            const collection = {
-                collectionKind: 'registration-list', path: statement.path, symbol, owner: statement.owner,
-                line: statement.startLine, anchor: statement.anchor,
-                ephemeral: statement.scope === 'function',
-                entries,
-            };
-            collections.set(statement.scope === 'module' ? symbol : `${statement.owner}.${symbol}`, collection);
-        }
-    }
-    return collections;
-}
-function moduleNames(path) {
-    const withoutExtension = normalizePath(path).replace(/\.pyi?$/, '').replace(/\/__init__$/, '');
-    const names = new Set([withoutExtension.replaceAll('/', '.')]);
-    const components = withoutExtension.split('/');
-    for (let index = 1; index < components.length; index += 1) {
-        if (['dist-packages', 'lib', 'site-packages', 'src'].includes(components[index - 1])) {
-            names.add(components.slice(index).join('.'));
-        }
-    }
-    return [...names];
-}
-function resolveImportModule(importerPath, specifier, modulePaths, knownPaths) {
-    if (!specifier.startsWith('.'))
-        return modulePaths.get(specifier) ?? null;
-    const dots = specifier.match(/^\.+/)?.[0].length ?? 0;
-    const suffix = specifier.slice(dots).split('.').filter(Boolean);
-    const base = dirname(importerPath).split('/').filter((component) => component !== '.');
-    for (let count = 1; count < dots; count += 1)
-        base.pop();
-    const joined = normalizePath([...base, ...suffix].join('/'));
-    return [`${joined}.py`, `${joined}/__init__.py`, `${joined}.pyi`]
-        .find((candidate) => knownPaths.has(candidate)) ?? null;
-}
-function importBindings(path, statements, modulePaths, knownPaths) {
-    const result = new Map();
-    for (const statement of statements) {
-        const fromImport = statement.text.match(/^from\s+([.A-Za-z_][.A-Za-z0-9_]*)\s+import\s+(.+)$/);
-        if (fromImport) {
-            const importedPath = resolveImportModule(path, fromImport[1], modulePaths, knownPaths);
-            if (!importedPath)
-                continue;
-            const importedSymbols = fromImport[2].trim().replace(/^\(|\)$/g, '');
-            for (const raw of splitTopLevel(importedSymbols, ',')) {
-                if (raw === '*') {
-                    result.set('*', { path: importedPath, symbol: '*' });
-                    continue;
-                }
-                const symbol = raw.match(/^([A-Za-z_][A-Za-z0-9_]*)(?:\s+as\s+([A-Za-z_][A-Za-z0-9_]*))?$/);
-                if (symbol)
-                    result.set(symbol[2] ?? symbol[1], { path: importedPath, symbol: symbol[1] });
-            }
-            continue;
-        }
-        const moduleImport = statement.text.match(/^import\s+([A-Za-z_][A-Za-z0-9_.]*)(?:\s+as\s+([A-Za-z_][A-Za-z0-9_]*))?$/);
-        if (!moduleImport)
-            continue;
-        const importedPath = resolveImportModule(path, moduleImport[1], modulePaths, knownPaths);
-        if (importedPath) {
-            result.set(moduleImport[2] ?? moduleImport[1].split('.').at(-1), {
-                path: importedPath,
-                symbol: '*',
-            });
-        }
-    }
-    return result;
-}
-function identifierParts(value) {
-    const parts = new Set();
-    for (const identifier of value.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []) {
-        const withBoundaries = identifier.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
-        withBoundaries.split('_').filter(Boolean).forEach((part) => parts.add(part));
-    }
-    return parts;
-}
-function escaped(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function dynamicSelectorExpression(value) {
-    const canonical = canonicalExpression(value);
-    if (decodePythonLiteral(canonical) !== null)
-        return false;
-    if (/^[A-Z_][A-Z0-9_]*$/.test(canonical))
-        return false;
-    if (/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+$/.test(canonical))
-        return false;
-    return /^[A-Za-z_][A-Za-z0-9_]*(?:\[[^\]]+\])?$/.test(canonical);
-}
-function mappingLookup(expression, binding) {
-    const symbol = escaped(binding);
-    const bracket = new RegExp(`${symbol}\\[([^\\u005d]+)\\]`).exec(expression);
-    const get = new RegExp(`${symbol}\\.get\\(([^,)]+)(?:,[^)]*)?\\)`).exec(expression);
-    const candidates = [bracket, get].filter((match) => match !== null)
-        .sort((left, right) => left.index - right.index);
-    const selected = candidates[0];
-    return selected ? { index: selected.index, text: selected[0], selector: selected[1] } : null;
-}
-function mappingGate(statement, binding) {
-    const text = statement.text;
-    const parts = identifierParts(text);
-    const ownerParts = identifierParts(statement.owner);
-    if ([...parts, ...ownerParts].some((part) => NEGATIVE_PIPELINE_PARTS.has(part))
-        || statement.owner.split('.').some((owner) => /^(?:test|tests)_/.test(owner.toLowerCase())))
-        return null;
-    const symbol = escaped(binding);
-    const canonical = canonicalExpression(text);
-    const lookup = mappingLookup(canonical, binding);
-    if (lookup && dynamicSelectorExpression(lookup.selector)) {
-        if (new RegExp(`^for.+in${escaped(lookup.text)}`).test(canonical))
-            return null;
-        const afterLookup = canonical.slice(lookup.index + lookup.text.length);
-        if (afterLookup.startsWith('('))
-            return 'behavior';
-        if (/^(?:return|yield)/.test(canonical))
-            return 'choice';
-        if (new RegExp(`^[A-Za-z_][A-Za-z0-9_.]*\\[[^\\u005d]+\\]=`).test(canonical))
-            return 'registration';
-        if (!/^[A-Za-z_][A-Za-z0-9_]*=/.test(canonical) && /\([^)]/.test(canonical))
-            return 'choice';
-    }
-    if (new RegExp(`(?:choices|options|values)=${symbol}\\.keys\\(\\)(?:[,)]|$)`).test(canonical)) {
-        return 'choice';
-    }
-    return null;
-}
-function mappingResultGate(statements, binding) {
-    for (let index = 0; index < statements.length; index += 1) {
-        const assignment = statements[index].text.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/);
-        if (!assignment)
-            continue;
-        const lookup = mappingLookup(canonicalExpression(assignment[2]), binding);
-        if (!lookup || !dynamicSelectorExpression(lookup.selector))
-            continue;
-        const assignmentParts = identifierParts(statements[index].text);
-        const ownerParts = identifierParts(statements[index].owner);
-        if ([...assignmentParts, ...ownerParts].some((part) => NEGATIVE_PIPELINE_PARTS.has(part))
-            || statements[index].owner.split('.').some((owner) => /^(?:test|tests)_/.test(owner.toLowerCase())))
-            continue;
-        const values = new Set([assignment[1]]);
-        const exhaustivelyIterated = statements.slice(index + 1).some((candidate) => candidate.owner === statements[index].owner
-            && new RegExp(`^\\s*for\\s+.+?\\s+in\\s+${escaped(assignment[1])}\\s*:`).test(candidate.text));
-        if (exhaustivelyIterated)
-            continue;
-        for (let cursor = index + 1; cursor < statements.length; cursor += 1) {
-            const candidate = statements[cursor];
-            if (candidate.owner !== statements[index].owner)
-                continue;
-            const alias = candidate.text.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([A-Za-z_][A-Za-z0-9_]*)$/);
-            if (alias && values.has(alias[2]))
-                values.add(alias[1]);
-            const canonical = canonicalExpression(candidate.text);
-            const selected = [...values].find((value) => new RegExp(`\\b${escaped(value)}\\b`).test(canonical));
-            if (!selected)
-                continue;
-            const parts = identifierParts(candidate.text);
-            if ([...parts].some((part) => NEGATIVE_PIPELINE_PARTS.has(part)))
-                continue;
-            const returned = new RegExp(`^(?:return|yield)${escaped(selected)}$`).test(canonical);
-            const configAssignment = new RegExp(`^[A-Za-z_][A-Za-z0-9_.]*\\[[^\\u005d]+\\]=${escaped(selected)}$`).test(canonical);
-            const call = new RegExp(`(?:^|[=(,])(?:[A-Za-z_][A-Za-z0-9_.]*\\()?[^(]*\\([^)]*\\b${escaped(selected)}\\b`).test(canonical);
-            if (returned || configAssignment || call) {
-                return {
-                    path: candidate.path,
-                    line: candidate.startLine,
-                    anchor: candidate.anchor,
-                    owner: candidate.owner,
-                    statement: `${statements[index].text} -> ${candidate.text}`,
-                };
-            }
-        }
-    }
-    return null;
-}
-function mappingHasMutation(statements, binding, collection) {
-    const symbol = escaped(binding);
-    return statements.some((statement) => {
-        if (statement.path === collection.path && statement.startLine === collection.line)
-            return false;
-        const canonical = canonicalExpression(statement.text);
-        return new RegExp('^(?:del)?' + symbol + '\\[[^\\u005d]+\\](?:=|$)').test(canonical)
-            || new RegExp('^' + symbol + '\\.(?:clear|pop|popitem|setdefault|update)\\(').test(canonical);
-    });
-}
-function registrationListGate(statements, loopIndex, binding) {
-    const loop = statements[loopIndex];
-    const symbol = escaped(binding);
-    const match = loop.text.match(new RegExp(`^for\\s+(.+?)\\s+in\\s+${symbol}\\s*:\\s*(.*)$`));
-    if (!match)
-        return null;
-    const variables = match[1].replace(/[()]/g, '').split(',').map((value) => value.trim());
-    if (variables.length < 2
-        || variables.some((variable) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(variable)))
-        return null;
-    const suite = [];
-    if (match[2])
-        suite.push({ ...loop, text: match[2] });
-    let cursor = loopIndex + 1;
-    while (cursor < statements.length && statements[cursor].indent > loop.indent) {
-        suite.push(statements[cursor]);
-        cursor += 1;
-    }
-    const keyVariable = escaped(variables[0]);
-    const implementationVariable = escaped(variables[1]);
-    for (const candidate of suite) {
-        const parts = identifierParts(candidate.text);
-        if ([...parts].some((part) => NEGATIVE_PIPELINE_PARTS.has(part)))
-            continue;
-        const canonical = canonicalExpression(candidate.text);
-        const addressAssignment = new RegExp(`^[A-Za-z_][A-Za-z0-9_.]*\\[${keyVariable}\\]=`).test(canonical);
-        const registrationCall = new RegExp(`(?:^|\\.)register\\([^)]*\\b${keyVariable}\\b`).test(canonical);
-        const preservesImplementation = new RegExp(`\\b${implementationVariable}\\b`).test(canonical);
-        if ((addressAssignment || registrationCall) && preservesImplementation) {
-            return {
-                gate: {
-                    path: candidate.path,
-                    line: candidate.startLine,
-                    anchor: candidate.anchor,
-                    owner: candidate.owner,
-                    statement: candidate.text,
-                },
-                variables,
-            };
-        }
-    }
-    return null;
-}
-function mappingIterationGate(statements, loopIndex, binding) {
-    const loop = statements[loopIndex];
-    const symbol = escaped(binding);
-    const match = loop.text.match(new RegExp(`^for\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*,\\s*([A-Za-z_][A-Za-z0-9_]*)`
-        + `\\s+in\\s+${symbol}\\.items\\(\\)\\s*:\\s*(.*)$`));
-    if (!match)
-        return null;
-    const suite = [];
-    if (match[3])
-        suite.push({ ...loop, text: match[3] });
-    let cursor = loopIndex + 1;
-    while (cursor < statements.length && statements[cursor].indent > loop.indent) {
-        suite.push(statements[cursor]);
-        cursor += 1;
-    }
-    const key = escaped(match[1]);
-    const implementation = escaped(match[2]);
-    const gate = suite.find((candidate) => {
-        const canonical = canonicalExpression(candidate.text);
-        return new RegExp(`^[A-Za-z_][A-Za-z0-9_.]*\\[${key}\\]=${implementation}$`).test(canonical)
-            || new RegExp(`(?:^|\\.)register\\(${key},${implementation}(?:,|\\))`).test(canonical);
-    });
-    return gate ? {
-        path: gate.path,
-        line: gate.startLine,
-        anchor: gate.anchor,
-        owner: gate.owner,
-        statement: gate.text,
-    } : null;
-}
-function interproceduralIterationGate(statements, binding, collectionKind) {
-    const definitions = statements.flatMap((statement) => {
-        const definition = statement.text.match(/^(?:async\s+def|def)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)/);
-        return definition ? [{ statement, name: definition[1], parameters: splitTopLevel(definition[2], ',')
-                    .map((parameter) => parameter.replace(/:.*/, '').replace(/=.*/, '').trim()) }] : [];
-    });
-    for (const definition of definitions) {
-        const callPattern = new RegExp(`(?:^|[^A-Za-z0-9_.])${escaped(definition.name)}\\(([^)]*)\\)`);
-        const call = statements.map((statement) => ({ statement, match: callPattern.exec(statement.text) }))
-            .find((candidate) => candidate.match && !/^(?:async\s+def|def)\s/.test(candidate.statement.text));
-        if (!call?.match)
-            continue;
-        const argumentsList = splitTopLevel(call.match[1], ',');
-        const argumentIndex = argumentsList.findIndex((argument) => canonicalExpression(argument) === canonicalExpression(binding));
-        const parameter = definition.parameters[argumentIndex];
-        if (!parameter || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(parameter))
-            continue;
-        const body = statements.filter((statement) => statement.owner === definition.name || statement.owner.startsWith(`${definition.name}.`));
-        if (collectionKind === 'mapping') {
-            for (let index = 0; index < body.length; index += 1) {
-                const gate = mappingIterationGate(body, index, parameter);
-                if (gate)
-                    return { gate, variables: null };
-            }
-        }
-        else {
-            for (let index = 0; index < body.length; index += 1) {
-                const gate = registrationListGate(body, index, parameter);
-                if (gate)
-                    return gate;
-            }
-        }
-    }
-    return null;
-}
-function generatedChoiceGate(statements, binding) {
-    const symbol = escaped(binding);
-    const joined = statements.find((statement) => new RegExp(`(['"])[^'"]*\\1\\.join\\(${symbol}\\)`).test(canonicalExpression(statement.text)));
-    if (!joined)
-        return null;
-    for (let index = 0; index < statements.length; index += 1) {
-        const loop = statements[index];
-        const enumeration = loop.text.match(/^for\s+([A-Za-z_][A-Za-z0-9_]*)\s*,\s*[A-Za-z_][A-Za-z0-9_]*\s+in\s+enumerate\(\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\)\s*:/);
-        if (!enumeration || canonicalExpression(enumeration[2]) === canonicalExpression(binding))
-            continue;
-        let cursor = index + 1;
-        while (cursor < statements.length && statements[cursor].indent > loop.indent) {
-            const canonical = canonicalExpression(statements[cursor].text);
-            if (new RegExp(`${symbol}\\[${escaped(enumeration[1])}\\]`).test(canonical)) {
-                return {
-                    path: statements[cursor].path,
-                    line: statements[cursor].startLine,
-                    anchor: statements[cursor].anchor,
-                    owner: statements[cursor].owner,
-                    statement: `${joined.text} -> ${statements[cursor].text}`,
-                };
-            }
-            cursor += 1;
-        }
-    }
-    return null;
-}
-function choiceListGate(statement, binding) {
-    const parts = identifierParts(statement.text);
-    if ([...parts].some((part) => NEGATIVE_PIPELINE_PARTS.has(part)))
-        return false;
-    const symbol = escaped(binding);
-    const canonical = canonicalExpression(statement.text);
-    const indexed = new RegExp(`(?:return|yield)${symbol}\\[([^\\u005d]+)\\]`).exec(canonical);
-    return new RegExp(`(?:choices|options|values)=${symbol}(?:[,)]|$)`).test(canonical)
-        || (indexed !== null && dynamicSelectorExpression(indexed[1]))
-        || new RegExp(`(?:^|[:(])[^:()]+\\bin${symbol}(?:[:)])`).test(canonical);
-}
-function pythonExportedSymbols(statements) {
-    const declaration = statements.find((statement) => /^__all__\s*=/.test(statement.text));
-    if (!declaration)
-        return null;
-    const body = declaration.text.replace(/^__all__\s*=\s*/, '');
-    const inner = unwrapCollection(body, '[', ']') ?? unwrapCollection(body, '(', ')');
-    if (inner === null)
-        return new Set();
-    const result = new Set();
-    for (const item of splitTopLevel(inner, ',')) {
-        const selector = decodePythonLiteral(item);
-        if (!selector?.startsWith('string:'))
-            continue;
-        try {
-            result.add(JSON.parse(selector.slice('string:'.length)));
-        }
-        catch {
-            continue;
-        }
-    }
-    return result;
-}
-function classOwner(collection) {
-    return collection.ephemeral || collection.owner === basename(collection.path)
-        ? null
-        : collection.owner;
-}
-function collectionBindingsForFile(path, statements, own, all, imports, exportsByPath) {
-    const bindings = new Map();
-    const classSymbolCounts = new Map();
-    for (const collection of own.values()) {
-        if (classOwner(collection)) {
-            classSymbolCounts.set(collection.symbol, (classSymbolCounts.get(collection.symbol) ?? 0) + 1);
-        }
-    }
-    for (const collection of own.values()) {
-        const owner = classOwner(collection);
-        bindings.set(collection.symbol, collection);
-        if (owner) {
-            bindings.set(`${owner}.${collection.symbol}`, collection);
-            if (classSymbolCounts.get(collection.symbol) === 1) {
-                bindings.set(`self.${collection.symbol}`, collection);
-                bindings.set(`cls.${collection.symbol}`, collection);
-            }
-        }
-    }
-    for (const [binding, target] of imports) {
-        const imported = all.get(target.path);
-        if (!imported)
-            continue;
-        if (target.symbol === '*') {
-            const exported = exportsByPath.get(target.path) ?? null;
-            for (const collection of imported.values()) {
-                const owner = classOwner(collection);
-                const exportedRoot = owner?.split('.')[0] ?? collection.symbol;
-                if (exported ? !exported.has(exportedRoot) : exportedRoot.startsWith('_'))
-                    continue;
-                const exposed = owner ? `${owner}.${collection.symbol}` : collection.symbol;
-                bindings.set(binding === '*' ? exposed : `${binding}.${exposed}`, collection);
-            }
-        }
-        else {
-            const moduleCollection = [...imported.values()].find((collection) => !classOwner(collection) && collection.symbol === target.symbol);
-            if (moduleCollection)
-                bindings.set(binding, moduleCollection);
-            for (const collection of imported.values()) {
-                const owner = classOwner(collection);
-                if (owner?.split('.')[0] === target.symbol) {
-                    const suffix = owner.split('.').slice(1);
-                    bindings.set([binding, ...suffix, collection.symbol].join('.'), collection);
-                }
-            }
-        }
-    }
-    let changed = true;
-    for (let pass = 0; changed && pass < statements.length + 1; pass += 1) {
-        changed = false;
-        for (const statement of statements) {
-            const alias = statement.text.match(/^([A-Za-z_][A-Za-z0-9_.]*)\s*=\s*([A-Za-z_][A-Za-z0-9_.]*)$/);
-            if (!alias || bindings.has(alias[1]))
-                continue;
-            const collection = bindings.get(alias[2]);
-            if (collection) {
-                bindings.set(alias[1], collection);
-                changed = true;
-            }
-        }
-    }
-    return [...bindings].map(([binding, collection]) => ({ binding, collection }));
-}
-function bindingAppliesToStatement(binding, collection, statement) {
-    if (collection.ephemeral)
-        return statement.owner === collection.owner;
-    const owner = classOwner(collection);
-    if (!owner)
-        return true;
-    if (binding === collection.symbol || binding.startsWith('self.') || binding.startsWith('cls.')) {
-        return statement.owner === owner || statement.owner.startsWith(`${owner}.`);
-    }
-    return true;
-}
-function resolveImplementationIdentity(expression, sourcePath, imports) {
-    if (expression === '$selector')
-        return expression;
-    const root = expression.match(/^([A-Za-z_][A-Za-z0-9_]*)/)?.[1];
-    const target = root ? imports.get(root) : undefined;
-    if (!target)
-        return `${sourcePath}#${expression}`;
-    const suffix = expression.slice(root.length).replace(/^\./, '.');
-    return target.symbol === '*'
-        ? `${target.path}#${suffix.replace(/^\./, '')}`
-        : `${target.path}#${target.symbol}${suffix}`;
-}
-function emitStaticCollection(collection, emissionKind, gate, loopVariables, sourceImports, records) {
-    const familyKind = emissionKind === 'mapping'
-        ? 'python-static-mapping-selector-family'
-        : emissionKind === 'choice'
-            ? 'python-static-choice-selector-family'
-            : 'python-static-registration-selector-family';
-    const entryKind = emissionKind === 'mapping'
-        ? 'python-static-mapping-selector-entry'
-        : emissionKind === 'choice'
-            ? 'python-static-choice-selector-entry'
-            : 'python-static-registration-selector-entry';
-    const ownerIdentity = `${collection.path}#${collection.owner}.${collection.symbol}`;
-    const signature = sha256(collection.entries.map((entry) => `${entry.selector}\0${entry.implementation}`).join('\0')).slice(0, 24);
-    const identity = `${emissionKind}:${collection.path}#${collection.symbol}:${signature}`;
-    const familyId = recordStableId(familyKind, gate.path, ownerIdentity, identity);
-    records.push({
-        kind: familyKind,
-        projections: ['registry_families'],
-        presumptiveInventory: true,
-        proofStatus: 'proof-complete',
-        path: gate.path,
-        line: gate.line,
-        anchor: gate.anchor,
-        owner: ownerIdentity,
-        identity,
-        tokens: [collection.symbol, canonicalExpression(gate.statement), 'proof-complete:python-static-registry'],
-        semanticIdentityKey: `python-registry-family\0${ownerIdentity}\0${emissionKind}\0${signature}`,
-        identityComponents: {
-            identity_kind: 'python-registry-family',
-            owner_identity: ownerIdentity,
-            selector_domain: `${collection.path}#${collection.symbol}`,
-        },
-    });
-    collection.entries.forEach((entry) => {
-        let implementation = resolveImplementationIdentity(entry.implementation, collection.path, sourceImports);
-        if (entry.implementation === '$selector' && loopVariables) {
-            let instantiated = canonicalExpression(gate.statement);
-            instantiated = instantiated.replace(new RegExp(`\\b${escaped(loopVariables[0])}\\b`, 'g'), JSON.stringify(entry.selector));
-            implementation = `${gate.path}#registration:${instantiated}`;
-        }
-        const entryIdentity = `${identity}:selector:${entry.selector}:implementation:${implementation}`;
-        records.push({
-            kind: entryKind,
-            projections: ['registry_entries'],
-            presumptiveInventory: true,
-            proofStatus: 'proof-complete',
-            path: collection.path,
-            line: entry.line,
-            anchor: entry.anchor,
-            owner: ownerIdentity,
-            identity: entryIdentity,
-            tokens: [entry.selector, implementation, 'proof-complete:python-static-registry'],
-            selectorKey: entry.selector,
-            implementationKey: implementation,
-            selectorFamilyRecordId: familyId,
-            semanticIdentityKey: `python-registry-entry\0${ownerIdentity}\0${emissionKind}\0${entry.selector}\0${implementation}`,
-            identityComponents: {
-                identity_kind: 'python-registry-entry',
-                owner_identity: ownerIdentity,
-                selector_domain: `${collection.path}#${collection.symbol}`,
-                selector_key: entry.selector,
-                implementation_identity: implementation,
-            },
-        });
-    });
-}
-function parseCopyAliases(repositoryRoot, trackedPaths, sources) {
-    const knownPaths = new Set(trackedPaths);
-    const aliases = new Map();
-    const resolvePair = (scriptPath, rawSource, rawTarget) => {
-        if (/^(?:[A-Za-z]+:|\/)/.test(rawSource) || /^(?:[A-Za-z]+:|\/)/.test(rawTarget))
-            return;
-        const sourceCandidates = [
-            normalizePath(rawSource),
-            normalizePath(posix.join(dirname(scriptPath), rawSource)),
-        ];
-        const targetCandidates = [
-            normalizePath(rawTarget),
-            normalizePath(posix.join(dirname(scriptPath), rawTarget)),
-        ];
-        const source = sourceCandidates.find((candidate) => knownPaths.has(candidate) || trackedPaths.some((path) => path.startsWith(`${candidate}/`)));
-        if (!source)
-            return;
-        let target = targetCandidates.find((candidate) => knownPaths.has(candidate));
-        if (!target) {
-            target = targetCandidates.map((candidate) => normalizePath(posix.join(candidate, basename(source))))
-                .find((candidate) => knownPaths.has(candidate));
-        }
-        if (!target && !knownPaths.has(source)) {
-            target = targetCandidates.find((candidate) => trackedPaths.some((path) => path.startsWith(`${candidate}/`)));
-        }
-        if (target && target !== source)
-            aliases.set(target, source);
-    };
-    for (const [path, source] of sources) {
-        if (isTestPath(path) || isDependencyPath(path))
-            continue;
-        for (const match of source.matchAll(/\b(?:shutil\.)?(?:copy|copy2|copyfile|copytree)\(\s*(['"])([^'"]+)\1\s*,\s*(['"])([^'"]+)\3/g))
-            resolvePair(path, match[2], match[4]);
-        for (const line of source.split(/\r?\n/)) {
-            const match = stripPythonComment(line).match(/^\s*cp\s+(?:-[A-Za-z]+\s+)?(?:['"]([^'"]+)['"]|(\S+))\s+(?:['"]([^'"]+)['"]|(\S+))\s*$/);
-            if (match)
-                resolvePair(path, match[1] ?? match[2], match[3] ?? match[4]);
-        }
-        if (!['.toml', '.yaml', '.yml'].includes(extname(path).toLowerCase()))
-            continue;
-        let section = '';
-        let structuredSource = null;
-        for (const line of source.split(/\r?\n/)) {
-            const header = line.match(/^\s*\[([^\]]+)]\s*$/);
-            if (header) {
-                section = header[1];
-                structuredSource = null;
-                continue;
-            }
-            const parts = identifierParts(section);
-            if (![...parts].some((part) => ['copy', 'package', 'resource'].includes(part)))
-                continue;
-            const property = line.match(/^\s*(source|destination|target)\s*[:=]\s*['"]([^'"]+)['"]\s*$/);
-            if (!property)
-                continue;
-            if (property[1] === 'source')
-                structuredSource = property[2];
-            else if (structuredSource)
-                resolvePair(path, structuredSource, property[2]);
-        }
-    }
-    const hashes = new Map();
-    const blobHash = (path) => {
-        if (hashes.has(path))
-            return hashes.get(path) ?? null;
-        try {
-            const stat = statSync(join(repositoryRoot, path));
-            const hash = stat.isFile() && stat.size <= MAX_SOURCE_BYTES
-                ? sha256(readFileSync(join(repositoryRoot, path)))
-                : null;
-            hashes.set(path, hash);
-            return hash;
-        }
-        catch {
-            hashes.set(path, null);
-            return null;
-        }
-    };
-    for (const target of trackedPaths) {
-        if (aliases.has(target) || isTestPath(target))
-            continue;
-        const tail = structuredPackageResourceTail(target);
-        if (!tail)
-            continue;
-        const targetHash = blobHash(target);
-        if (!targetHash)
-            continue;
-        const candidates = trackedPaths.filter((candidate) => candidate !== target
-            && structuredPackageResourceTail(candidate) === null
-            && (candidate === tail || candidate.endsWith(`/${tail}`))
-            && blobHash(candidate) === targetHash);
-        if (candidates.length === 1)
-            aliases.set(target, candidates[0]);
-    }
-    const packageDirectories = [...trackedDirectories(trackedPaths)]
-        .filter((directory) => structuredPackageResourceTail(`${directory}/placeholder`) !== null)
-        .sort((left, right) => right.length - left.length);
-    for (const targetDirectory of packageDirectories) {
-        const descendants = trackedPaths.filter((path) => path.startsWith(`${targetDirectory}/`));
-        if (descendants.length === 0)
-            continue;
-        const sourceDirectories = new Set();
-        let complete = true;
-        for (const target of descendants) {
-            const source = aliases.get(target);
-            const relative = target.slice(targetDirectory.length + 1);
-            if (!source || !(source === relative || source.endsWith(`/${relative}`))) {
-                complete = false;
-                break;
-            }
-            sourceDirectories.add(source.slice(0, source.length - relative.length).replace(/\/$/, ''));
-        }
-        if (complete && sourceDirectories.size === 1) {
-            const sourceDirectory = [...sourceDirectories][0];
-            if (sourceDirectory)
-                aliases.set(targetDirectory, sourceDirectory);
-        }
-    }
-    return aliases;
-}
-function structuredPackageResourceTail(path) {
-    const components = normalizePath(path).split('/');
-    const packageSuffixes = ['.app', '.appex', '.bundle', '.plugin', '.xpc'];
-    for (let index = 0; index < components.length; index += 1) {
-        const lower = components[index].toLowerCase();
-        if (packageSuffixes.some((suffix) => lower.endsWith(suffix))) {
-            if (components[index + 1]?.toLowerCase() === 'contents'
-                && ['plugins', 'resources', 'sharedsupport'].includes(components[index + 2]?.toLowerCase()))
-                return components.slice(index + 3).join('/') || null;
-            if (components[index + 1]?.toLowerCase() === 'resources') {
-                return components.slice(index + 2).join('/') || null;
-            }
-        }
-        if (lower.endsWith('.framework') && components[index + 1]?.toLowerCase() === 'resources') {
-            return components.slice(index + 2).join('/') || null;
-        }
-    }
-    return null;
-}
-function canonicalCopiedPath(path, aliases) {
-    let current = normalizePath(path);
-    const seen = new Set();
-    while (!seen.has(current)) {
-        seen.add(current);
-        const exact = aliases.get(current);
-        if (exact) {
-            current = exact;
-            continue;
-        }
-        const prefix = [...aliases.keys()]
-            .filter((candidate) => current.startsWith(`${candidate}/`))
-            .sort((left, right) => right.length - left.length)[0];
-        if (!prefix)
-            break;
-        current = normalizePath(posix.join(aliases.get(prefix), current.slice(prefix.length + 1)));
-    }
-    return current;
-}
-function parseIni(source) {
-    const sections = new Map();
-    let section = '';
-    source.split(/\r?\n/).forEach((line, index) => {
-        const header = line.match(/^\s*\[([^\]]+)]\s*(?:[;#].*)?$/);
-        if (header) {
-            section = header[1].trim();
-            sections.set(section, sections.get(section) ?? []);
-            return;
-        }
-        if (!section || /^\s*[;#]/.test(line))
-            return;
-        const property = line.match(/^\s*([^=]+?)\s*=\s*(.*?)\s*$/);
-        if (!property)
-            return;
-        const values = sections.get(section) ?? [];
-        values.push({ key: property[1].trim(), value: property[2], line: index + 1, anchor: line });
-        sections.set(section, values);
-    });
-    return sections;
-}
-function firstIniValue(entries, keys) {
-    for (const key of keys) {
-        const entry = entries.find((candidate) => candidate.key.toLowerCase() === key);
-        if (entry && entry.value !== '')
-            return entry.value;
-    }
-    return null;
-}
-function scanInstallManifests(root, paths, sources, aliases, records) {
-    const seen = new Set();
-    for (const originalPath of paths.filter((path) => basename(path).toLowerCase() === 'install.inf')) {
-        if (isTestPath(originalPath) || isDependencyPath(originalPath))
-            continue;
-        const path = canonicalCopiedPath(originalPath, aliases);
-        if (seen.has(path))
-            continue;
-        const source = sources.get(path) ?? sources.get(originalPath) ?? readText(root, path);
-        if (!source)
-            continue;
-        const sections = parseIni(source);
-        const infoName = [...sections.keys()].find((section) => section.toLowerCase() === 'info');
-        if (!infoName)
-            continue;
-        const info = sections.get(infoName);
-        const namespace = firstIniValue(info, MANIFEST_NAMESPACE_KEYS);
-        const manifestType = firstIniValue(info, ['type']);
-        if (!namespace)
-            continue;
-        const entries = [];
-        for (const [section, properties] of sections) {
-            if (section.toLowerCase() === 'info' || properties.length === 0)
-                continue;
-            const method = firstIniValue(properties, ['method']);
-            const implementation = method
-                ? `${namespace}.${method}`
-                : `${path}#[${section}]:declarative:${sha256(properties.map((property) => `${property.key}\0${property.value}`).join('\0')).slice(0, 24)}`;
-            const evidence = properties[0];
-            entries.push({
-                selector: section,
-                implementation,
-                line: evidence.line,
-                anchor: evidence.anchor,
-            });
-        }
-        if (entries.length === 0)
-            continue;
-        const owner = `install.inf:${path}#manifest`;
-        const identity = `${path}#manifest`;
-        const familyKind = 'install-inf-selector-family';
-        const familyId = recordStableId(familyKind, path, owner, identity);
-        const first = entries[0];
-        records.push({
-            kind: familyKind,
-            projections: ['registry_families'],
-            presumptiveInventory: true,
-            proofStatus: 'proof-complete',
-            path,
-            line: first.line,
-            anchor: first.anchor,
-            owner,
-            identity,
-            tokens: [namespace, ...(manifestType ? [manifestType] : []), ...entries.map((entry) => entry.selector),
-                'proof-complete:install-inf-registry'],
-            semanticIdentityKey: `manifest-registry-family\0${path}\0manifest`,
-            identityComponents: {
-                identity_kind: 'manifest-registry-family',
-                owner_identity: `${path}#manifest`,
-                selector_domain: `${path}#manifest-sections`,
-            },
-        });
-        entries.forEach((entry) => {
-            const entryIdentity = `${identity}:section:${entry.selector}:implementation:${entry.implementation}`;
-            records.push({
-                kind: 'install-inf-selector-entry',
-                projections: ['registry_entries'],
-                presumptiveInventory: true,
-                proofStatus: 'proof-complete',
-                path,
-                line: entry.line,
-                anchor: entry.anchor,
-                owner,
-                identity: entryIdentity,
-                tokens: [entry.selector, entry.implementation, 'proof-complete:install-inf-registry'],
-                selectorKey: entry.selector,
-                implementationKey: entry.implementation,
-                selectorFamilyRecordId: familyId,
-                semanticIdentityKey: `manifest-registry-entry\0${path}\0${entry.selector}\0${entry.implementation}`,
-                identityComponents: {
-                    identity_kind: 'manifest-registry-entry',
-                    owner_identity: `${path}#manifest`,
-                    selector_domain: `${path}#manifest-sections`,
-                    selector_key: entry.selector,
-                    implementation_identity: entry.implementation,
-                },
-            });
-        });
-        seen.add(path);
-    }
-}
-function trackedDirectories(paths) {
-    const result = new Set();
-    for (const path of paths) {
-        const components = normalizePath(path).split('/');
-        for (let length = 1; length < components.length; length += 1) {
-            result.add(components.slice(0, length).join('/'));
-        }
-    }
-    return result;
-}
-function exactStringLiterals(expression) {
-    return [...expression.matchAll(/(['"])([^'"]+)\1/g)].map((match) => match[2]);
-}
-function uniqueDirectory(candidates, directories) {
-    const existing = [...new Set([...candidates].map(normalizePath))]
-        .filter((candidate) => directories.has(candidate));
-    return existing.length === 1 ? existing[0] : null;
-}
-function pythonMaterializationRoots(path, statements, trackedPaths, modulePaths, aliases) {
-    const directories = new Set([...trackedDirectories(trackedPaths)]
-        .filter((directory) => !isTestPath(`${directory}/placeholder`) && !isDependencyPath(`${directory}/placeholder`))
-        .map((directory) => canonicalCopiedPath(directory, aliases)));
-    const roots = new Map();
-    const assignments = statements.flatMap((statement) => {
-        const match = statement.text.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*(?::[^=]+)?=\s*(.+)$/);
-        return match ? [{ statement, symbol: match[1], expression: match[2] }] : [];
-    });
-    const literalConstants = new Map();
-    assignments.forEach((assignment) => {
-        const literal = assignment.expression.match(/^(['"])([^'"]+)\1$/);
-        if (literal)
-            literalConstants.set(assignment.symbol, literal[2]);
-    });
-    const resolved = new Map();
-    let changed = true;
-    for (let pass = 0; changed && pass < assignments.length + 2; pass += 1) {
-        changed = false;
-        for (const assignment of assignments) {
-            const candidates = new Set(resolved.get(assignment.symbol) ?? []);
-            const literals = exactStringLiterals(assignment.expression);
-            if (/\bfiles\s*\(/.test(assignment.expression) && literals.length > 0) {
-                const modulePath = modulePaths.get(literals[0]);
-                if (modulePath)
-                    candidates.add(normalizePath(posix.join(dirname(modulePath), ...literals.slice(1))));
-            }
-            if (/\b__file__\b/.test(assignment.expression)) {
-                const parentCount = (assignment.expression.match(/\.parent\b/g) ?? []).length
-                    + (assignment.expression.match(/(?:os\.path\.)?dirname\s*\(\s*__file__\s*\)/g) ?? []).length;
-                let basePath = path;
-                for (let count = 0; count < Math.max(1, parentCount); count += 1)
-                    basePath = dirname(basePath);
-                const pathLiterals = /\bfiles\s*\(/.test(assignment.expression) ? literals.slice(1) : literals;
-                candidates.add(normalizePath(posix.join(basePath, ...pathLiterals)));
-            }
-            else if (/\bPath\s*\(/.test(assignment.expression) && literals.length > 0) {
-                candidates.add(normalizePath(posix.join(...literals)));
-                candidates.add(normalizePath(posix.join(dirname(path), ...literals)));
-            }
-            if (/\bos\.path\.join\s*\(/.test(assignment.expression) && literals.length > 0) {
-                const suffix = normalizePath(posix.join(...literals));
-                directories.forEach((directory) => {
-                    if (directory === suffix || directory.endsWith(`/${suffix}`))
-                        candidates.add(directory);
-                });
-            }
-            for (const [binding, baseCandidates] of resolved) {
-                if (!new RegExp(`\\b${escaped(binding)}\\b`).test(assignment.expression))
-                    continue;
-                const suffixes = exactStringLiterals(assignment.expression);
-                for (const reference of assignment.expression.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []) {
-                    const constant = literalConstants.get(reference);
-                    if (constant)
-                        suffixes.push(constant);
-                }
-                const exactAlias = canonicalExpression(assignment.expression) === binding;
-                if (!exactAlias && suffixes.length === 0)
-                    continue;
-                for (const base of baseCandidates)
-                    candidates.add(normalizePath(posix.join(base, ...suffixes)));
-            }
-            const existing = new Set([...candidates]
-                .map((candidate) => canonicalCopiedPath(candidate, aliases))
-                .filter((candidate) => directories.has(candidate)));
-            const before = resolved.get(assignment.symbol);
-            if (existing.size > 0 && (!before || [...existing].some((candidate) => !before.has(candidate)))) {
-                resolved.set(assignment.symbol, existing);
-                changed = true;
-            }
-        }
-    }
-    for (const assignment of assignments) {
-        const rootPath = uniqueDirectory(resolved.get(assignment.symbol) ?? [], directories);
-        if (!rootPath || roots.has(assignment.symbol))
-            continue;
-        roots.set(assignment.symbol, {
-            path,
-            symbol: assignment.symbol,
-            owner: assignment.statement.owner,
-            line: assignment.statement.startLine,
-            anchor: assignment.statement.anchor,
-            rootPath,
-        });
-    }
-    return roots;
-}
-function pascalStatements(path, source) {
-    const result = [];
-    let blockComment = false;
-    source.split(/\r?\n/).forEach((original, index) => {
-        let line = original;
-        if (blockComment) {
-            const end = line.indexOf('}');
-            if (end < 0)
-                return;
-            line = line.slice(end + 1);
-            blockComment = false;
-        }
-        const start = line.indexOf('{');
-        if (start >= 0) {
-            const end = line.indexOf('}', start + 1);
-            if (end >= 0)
-                line = `${line.slice(0, start)} ${line.slice(end + 1)}`;
-            else {
-                line = line.slice(0, start);
-                blockComment = true;
-            }
-        }
-        line = line.replace(/\/\/.*$/, '').trim();
-        if (!line)
-            return;
-        result.push({
-            path,
-            startLine: index + 1,
-            endLine: index + 1,
-            indent: indentation(original),
-            text: line.replace(/;\s*$/, ''),
-            anchor: original,
-            owner: basename(path),
-            scope: 'module',
-        });
-    });
-    return result;
-}
-function pascalMaterializationRoots(path, statements, trackedPaths, aliases) {
-    const directories = new Set([...trackedDirectories(trackedPaths)]
-        .filter((directory) => !isTestPath(`${directory}/placeholder`) && !isDependencyPath(`${directory}/placeholder`))
-        .map((directory) => canonicalCopiedPath(directory, aliases)));
-    const roots = new Map();
-    const literalConstants = new Map();
-    const assignments = statements.flatMap((statement) => {
-        const match = statement.text.match(/^(?:const\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*(?::?=)\s*(.+)$/i);
-        if (!match)
-            return [];
-        const literal = match[2].match(/^(['"])([^'"]+)\1$/);
-        if (literal)
-            literalConstants.set(match[1].toLowerCase(), literal[2]);
-        return [{ statement, symbol: match[1], expression: match[2] }];
-    });
-    const resolved = new Map();
-    let changed = true;
-    for (let pass = 0; changed && pass < assignments.length + 2; pass += 1) {
-        changed = false;
-        for (const assignment of assignments) {
-            const candidates = new Set(resolved.get(assignment.symbol.toLowerCase()) ?? []);
-            const literals = exactStringLiterals(assignment.expression);
-            for (const reference of assignment.expression.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? []) {
-                const constant = literalConstants.get(reference.toLowerCase());
-                if (constant)
-                    literals.push(constant);
-                for (const base of resolved.get(reference.toLowerCase()) ?? []) {
-                    candidates.add(normalizePath(posix.join(base, ...literals)));
-                }
-            }
-            if (literals.length > 0 && /(?:ExtractFile|IncludeTrailingPathDelimiter|TPath\.Combine|PathDelim|DirectorySeparator)/i.test(assignment.expression)) {
-                const suffix = normalizePath(posix.join(...literals));
-                directories.forEach((directory) => {
-                    if (directory === suffix || directory.endsWith(`/${suffix}`))
-                        candidates.add(directory);
-                });
-                candidates.add(normalizePath(posix.join(dirname(path), suffix)));
-                candidates.add(suffix);
-            }
-            const existing = new Set([...candidates]
-                .map((candidate) => canonicalCopiedPath(candidate, aliases))
-                .filter((candidate) => directories.has(candidate)));
-            const key = assignment.symbol.toLowerCase();
-            const before = resolved.get(key);
-            if (existing.size > 0 && (!before || [...existing].some((candidate) => !before.has(candidate)))) {
-                resolved.set(key, existing);
-                changed = true;
-            }
-        }
-    }
-    for (const assignment of assignments) {
-        const rootPath = uniqueDirectory(resolved.get(assignment.symbol.toLowerCase()) ?? [], directories);
-        if (!rootPath || roots.has(assignment.symbol))
-            continue;
-        roots.set(assignment.symbol, {
-            path,
-            symbol: assignment.symbol,
-            owner: assignment.statement.owner,
-            line: assignment.statement.startLine,
-            anchor: assignment.statement.anchor,
-            rootPath,
-        });
-    }
-    return roots;
-}
-function resourceUse(statement, binding, joinedPath = false) {
-    const symbol = escaped(binding);
-    const canonical = canonicalExpression(statement.text);
-    if (joinedPath) {
-        const directOpen = canonical.match(new RegExp(`open\\(${symbol}(?:,([^)]*))?\\)`));
-        if (directOpen) {
-            return /(['"])[wax+][^'"]*\1/.test(directOpen[1] ?? '') ? { kind: 'write' } : { kind: 'load' };
-        }
-        if (new RegExp(`${symbol}\\.(?:open|read_text|read_bytes)\\(`).test(canonical)
-            || new RegExp(`(?:InitLibrary|LoadFromDir|LoadFromFile|ReadAllText|ReadAllBytes|TFileStream\\.Create)\\(${symbol}(?:,|\\))`, 'i').test(canonical)) {
-            return { kind: 'load' };
-        }
-        if (new RegExp(`${symbol}\\.(?:mkdir|touch|write_bytes|write_text)\\(`).test(canonical)
-            || new RegExp(`(?:SaveToFile|WriteAllText|WriteAllBytes|DeleteFile)\\(${symbol}(?:,|\\))`, 'i').test(canonical)) {
-            return { kind: 'write' };
-        }
-    }
-    const pythonGlob = canonical.match(new RegExp(`${symbol}\\.(glob|rglob)\\((['"])([^'"]+)\\2\\)`));
-    if (pythonGlob)
-        return {
-            kind: 'enumerate', filter: pythonGlob[3], recursive: pythonGlob[1] === 'rglob', entryKind: 'file',
-        };
-    if (new RegExp(`${symbol}\\.iterdir\\(`).test(canonical)
-        || new RegExp(`(?:os\\.)?(?:listdir|scandir)\\(${symbol}\\)`).test(canonical)) {
-        const suffix = canonical.match(/\.suffix==(['"])([^'"]+)\1/)?.[2];
-        return { kind: 'enumerate', filter: suffix ? `*${suffix}` : '*', recursive: false, entryKind: 'either' };
-    }
-    const findAllFiles = canonical.match(new RegExp(`FindAllFiles\\([^,]+,${symbol},(['"])([^'"]+)\\1,(true|false)\\)`, 'i'));
-    if (findAllFiles)
-        return {
-            kind: 'enumerate', filter: findAllFiles[2], recursive: findAllFiles[3].toLowerCase() === 'true',
-            entryKind: 'file',
-        };
-    const pascalEnumeration = canonical.match(new RegExp(`(?:FindFirst|TDirectory\\.GetFiles)\\([^)]*${symbol}[^'"]*(['"])([^'"]*[?*][^'"]*)\\1`, 'i'));
-    if (pascalEnumeration)
-        return {
-            kind: 'enumerate', filter: pascalEnumeration[2], recursive: false, entryKind: 'file',
-        };
-    if (new RegExp(`(?:^|[^A-Za-z0-9_])LoadFromDir\\(${symbol}(?:,|\\))`, 'i').test(canonical)) {
-        return { kind: 'materialize', filter: '*', recursive: false, entryKind: 'file' };
-    }
-    if (new RegExp(`(?:^|[^A-Za-z0-9_])InitLibrary\\(${symbol}(?:,|\\))`, 'i').test(canonical)) {
-        return { kind: 'materialize', filter: '*', recursive: false, entryKind: 'directory' };
-    }
-    if (new RegExp(`${symbol}/[A-Za-z_][A-Za-z0-9_]*[^;]*\\.(?:open|read_text|read_bytes)\\(`).test(canonical)
-        || new RegExp(`${symbol}\\.joinpath\\([A-Za-z_][A-Za-z0-9_]*\\)\\.(?:open|read_text|read_bytes)\\(`).test(canonical)
-        || new RegExp(`open\\([^)]*${symbol}/[A-Za-z_][A-Za-z0-9_]*`).test(canonical)
-        || new RegExp(`open\\(os\\.path\\.join\\(${symbol},[A-Za-z_][A-Za-z0-9_]*\\)`).test(canonical)
-        || new RegExp(`(?:LoadFromFile|ReadAllText|ReadAllBytes|TFileStream\\.Create)\\([^)]*${symbol}[^)]*[A-Za-z_][A-Za-z0-9_]*`, 'i').test(canonical))
-        return { kind: 'load' };
-    if (new RegExp(`${symbol}(?:/[^;]+|\\.joinpath\\([^)]*\\))\\.(?:mkdir|touch|write_bytes|write_text)\\(`).test(canonical)
-        || new RegExp(`(?:copy|copy2|copyfile|copytree)\\([^)]*,[^)]*${symbol}`).test(canonical)
-        || new RegExp(`(?:SaveToFile|WriteAllText|WriteAllBytes|DeleteFile|fmCreate)[^;]*${symbol}`, 'i').test(canonical))
-        return { kind: 'write' };
-    return null;
-}
-function joinedPathBindings(statements, rootBinding) {
-    const result = new Set();
-    let changed = true;
-    for (let pass = 0; changed && pass < statements.length + 1; pass += 1) {
-        changed = false;
-        const sources = [rootBinding, ...result];
-        for (const statement of statements) {
-            const assignment = statement.text.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*(?::?=)\s*(.+)$/);
-            if (!assignment || result.has(assignment[1]) || assignment[1] === rootBinding)
-                continue;
-            const source = sources.find((binding) => new RegExp(`\\b${escaped(binding)}\\b`, 'i').test(assignment[2]));
-            if (!source)
-                continue;
-            const pathJoin = /(?:os\.path\.join|joinpath|TPath\.Combine|DirectorySeparator|PathDelim)/i.test(assignment[2])
-                || new RegExp(`\\b${escaped(source)}\\b\\s*[/+]`, 'i').test(assignment[2]);
-            if (!pathJoin)
-                continue;
-            const remainingIdentifiers = (assignment[2].match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [])
-                .filter((identifier) => identifier.toLowerCase() !== source.toLowerCase())
-                .filter((identifier) => ![
-                'directoryseparator', 'join', 'joinpath', 'os', 'path', 'pathdelim',
-                'tpath',
-            ].includes(identifier.toLowerCase()));
-            if (remainingIdentifiers.length === 0)
-                continue;
-            result.add(assignment[1]);
-            changed = true;
-        }
-    }
-    return [...result];
-}
-function globMatches(value, filter) {
-    const pattern = filter.replace(/[.+^${}()|[\]\\]/g, '\\$&').replaceAll('?', '.').replaceAll('*', '.*');
-    return new RegExp(`^${pattern}$`).test(value);
-}
-function emitResourceProviders(paths, statementsByPath, rootsByPath, importsByPath, aliases, records) {
-    const emitted = new Set();
-    for (const consumerPath of [...statementsByPath.keys()].filter((path) => !isTestPath(path) && !isDependencyPath(path))) {
-        const statements = statementsByPath.get(consumerPath) ?? [];
-        const bindings = new Map(rootsByPath.get(consumerPath));
-        for (const [binding, target] of importsByPath.get(consumerPath) ?? []) {
-            const importedRoots = rootsByPath.get(target.path);
-            if (!importedRoots)
-                continue;
-            if (target.symbol === '*') {
-                for (const [symbol, root] of importedRoots) {
-                    bindings.set(binding === '*' ? symbol : `${binding}.${symbol}`, root);
-                }
-            }
-            else {
-                const root = importedRoots.get(target.symbol);
-                if (root)
-                    bindings.set(binding, root);
-            }
-        }
-        for (const [binding, root] of bindings) {
-            const joinedBindings = joinedPathBindings(statements, binding);
-            const uses = statements.flatMap((statement) => [
-                { statement, use: resourceUse(statement, binding) },
-                ...joinedBindings.map((joined) => ({
-                    statement,
-                    use: resourceUse(statement, joined, true),
-                })),
-            ]);
-            const enumeration = uses.find((candidate) => candidate.use?.kind === 'enumerate' || candidate.use?.kind === 'materialize');
-            const load = uses.find((candidate) => candidate.use?.kind === 'load' || candidate.use?.kind === 'materialize');
-            if (!enumeration || !load || uses.some((candidate) => candidate.use?.kind === 'write'))
-                continue;
-            const filter = enumeration.use?.filter ?? '*';
-            let entryKind = enumeration.use?.entryKind ?? 'either';
-            if (entryKind === 'either' && joinedBindings.length > 0) {
-                const resourceBindings = joinedBindings.map(escaped).join('|');
-                const hasDirectoryCheck = statements.some((statement) => {
-                    const canonical = canonicalExpression(statement.text);
-                    return new RegExp(`(?:isdir|DirectoryExists)\\([^)]*(?:${resourceBindings})`, 'i').test(canonical);
-                });
-                const hasFileCheck = statements.some((statement) => {
-                    const canonical = canonicalExpression(statement.text);
-                    return new RegExp(`(?:isfile|FileExists)\\([^)]*(?:${resourceBindings})`, 'i').test(canonical);
-                });
-                if (hasDirectoryCheck !== hasFileCheck)
-                    entryKind = hasDirectoryCheck ? 'directory' : 'file';
-            }
-            const canonicalRoot = canonicalCopiedPath(root.rootPath, aliases);
-            const rootIdentity = `${root.path}#${root.symbol}:${canonicalRoot}:filter:${filter}:entries:${entryKind}`;
-            if (emitted.has(rootIdentity))
-                continue;
-            const children = new Set();
-            for (const tracked of paths) {
-                if (!tracked.startsWith(`${root.rootPath}/`))
-                    continue;
-                const relative = tracked.slice(root.rootPath.length + 1);
-                if (!relative)
-                    continue;
-                const recursive = enumeration.use?.recursive ?? false;
-                if (recursive && entryKind !== 'directory') {
-                    if (globMatches(basename(relative), filter))
-                        children.add(canonicalCopiedPath(tracked, aliases));
-                    continue;
-                }
-                const first = relative.split('/')[0];
-                if (relative.includes('/')) {
-                    if (entryKind !== 'file' && filter === '*') {
-                        children.add(canonicalCopiedPath(`${root.rootPath}/${first}`, aliases));
-                    }
-                }
-                else if (entryKind !== 'directory' && globMatches(first, filter)) {
-                    children.add(canonicalCopiedPath(tracked, aliases));
-                }
-            }
-            if (children.size === 0)
-                continue;
-            const familyKind = 'resource-provider-selector-family';
-            const owner = `${root.path}#${root.owner}.${root.symbol}`;
-            const identity = `resource-provider:${rootIdentity}`;
-            const familyId = recordStableId(familyKind, enumeration.statement.path, owner, identity);
-            records.push({
-                kind: familyKind,
-                projections: ['registry_families'],
-                presumptiveInventory: true,
-                proofStatus: 'proof-complete',
-                path: enumeration.statement.path,
-                line: enumeration.statement.startLine,
-                anchor: enumeration.statement.anchor,
-                owner,
-                identity,
-                tokens: [canonicalRoot, `filter:${filter}`, canonicalExpression(load.statement.text),
-                    'proof-complete:resource-provider-registry'],
-                semanticIdentityKey: `resource-registry-family\0${rootIdentity}`,
-                identityComponents: {
-                    identity_kind: 'resource-registry-family',
-                    owner_identity: owner,
-                    selector_domain: canonicalRoot,
-                    selector_filter: filter,
-                    selector_entry_kind: entryKind,
-                },
-            });
-            [...children].sort().forEach((child) => {
-                const implementation = `repository-resource:${child}`;
-                const entryIdentity = `${identity}:selector:${child}:implementation:${implementation}`;
-                records.push({
-                    kind: 'resource-provider-selector-entry',
-                    projections: ['registry_entries'],
-                    presumptiveInventory: true,
-                    proofStatus: 'proof-complete',
-                    path: load.statement.path,
-                    line: load.statement.startLine,
-                    anchor: load.statement.anchor,
-                    owner,
-                    identity: entryIdentity,
-                    tokens: [child, canonicalRoot, 'proof-complete:resource-provider-registry'],
-                    selectorKey: child,
-                    implementationKey: implementation,
-                    selectorFamilyRecordId: familyId,
-                    semanticIdentityKey: `resource-registry-entry\0${rootIdentity}\0${child}\0${implementation}`,
-                    identityComponents: {
-                        identity_kind: 'resource-registry-entry',
-                        owner_identity: owner,
-                        selector_domain: canonicalRoot,
-                        selector_filter: filter,
-                        selector_entry_kind: entryKind,
-                        selector_key: child,
-                        implementation_identity: implementation,
-                    },
-                });
-            });
-            emitted.add(rootIdentity);
-        }
-    }
-}
-export function scanPythonManifestSelectorIdentities(repositoryRoot, trackedPaths) {
-    const paths = [...new Set(trackedPaths.map(normalizePath))].sort();
-    const knownPaths = new Set(paths);
-    const sources = new Map();
-    for (const path of paths) {
-        const source = readText(repositoryRoot, path);
-        if (source !== null)
-            sources.set(path, source);
-    }
-    const structuredDependencyPrefixes = structuredDependencyPackagePrefixes(paths, sources);
-    const aliases = parseCopyAliases(repositoryRoot, paths, sources);
-    const pythonPaths = paths.filter((path) => PYTHON_EXTENSIONS.has(extname(path).toLowerCase())
-        && !isTestPath(path)
-        && canonicalCopiedPath(path, aliases) === path);
-    const statementsByPath = new Map();
-    const collectionsByPath = new Map();
-    const exportsByPath = new Map();
-    const modulePathCandidates = new Map();
-    for (const path of pythonPaths) {
-        moduleNames(path).forEach((moduleName) => {
-            const candidates = modulePathCandidates.get(moduleName) ?? new Set();
-            candidates.add(path);
-            modulePathCandidates.set(moduleName, candidates);
-        });
-    }
-    const modulePaths = new Map();
-    modulePathCandidates.forEach((candidates, moduleName) => {
-        if (candidates.size === 1)
-            modulePaths.set(moduleName, [...candidates][0]);
-    });
-    for (const path of pythonPaths) {
-        const source = sources.get(path);
-        if (!source)
-            continue;
-        const statements = pythonStatements(path, source);
-        statementsByPath.set(path, statements);
-        collectionsByPath.set(path, parseStaticCollections(statements));
-        exportsByPath.set(path, pythonExportedSymbols(statements));
-    }
-    const importsByPath = new Map();
-    for (const path of pythonPaths) {
-        importsByPath.set(path, importBindings(path, statementsByPath.get(path) ?? [], modulePaths, knownPaths));
-    }
-    const records = [];
-    for (const path of pythonPaths.filter((candidate) => !isStructuredDependencyPath(candidate, structuredDependencyPrefixes))) {
-        emitEqualityChains(statementsByPath.get(path) ?? [], records);
-    }
-    const emittedCollections = new Set();
-    for (const path of pythonPaths.filter((candidate) => !isStructuredDependencyPath(candidate, structuredDependencyPrefixes))) {
-        const statements = statementsByPath.get(path) ?? [];
-        const bindings = collectionBindingsForFile(path, statements, collectionsByPath.get(path) ?? new Map(), collectionsByPath, importsByPath.get(path) ?? new Map(), exportsByPath);
-        for (const { binding, collection } of bindings) {
-            if (isStructuredDependencyPath(collection.path, structuredDependencyPrefixes))
-                continue;
-            const applicableStatements = statements.filter((statement) => bindingAppliesToStatement(binding, collection, statement));
-            const identity = `${collection.path}#${collection.symbol}`;
-            if (emittedCollections.has(identity))
-                continue;
-            if (collection.collectionKind === 'mapping') {
-                if (new Set(collection.entries.map((entry) => entry.implementation)).size < 2
-                    || mappingHasMutation(applicableStatements, binding, collection))
-                    continue;
-                const gates = applicableStatements.flatMap((candidate) => {
-                    if (candidate.path === collection.path && candidate.startLine === collection.line)
-                        return [];
-                    const gateKind = mappingGate(candidate, binding);
-                    return gateKind ? [{ statement: candidate, gateKind }] : [];
-                });
-                let iterationGate = null;
-                for (let index = 0; index < applicableStatements.length && !iterationGate; index += 1) {
-                    iterationGate = mappingIterationGate(applicableStatements, index, binding);
-                }
-                iterationGate ??= interproceduralIterationGate(applicableStatements, binding, collection.collectionKind)?.gate ?? null;
-                const resultGate = mappingResultGate(applicableStatements, binding);
-                const selected = gates.sort((left, right) => {
-                    const rank = { behavior: 0, registration: 1, choice: 2 };
-                    return rank[left.gateKind] - rank[right.gateKind]
-                        || left.statement.startLine - right.statement.startLine;
-                })[0];
-                if (!selected && !iterationGate && !resultGate)
-                    continue;
-                const gate = iterationGate ?? resultGate ?? {
-                    path: selected.statement.path,
-                    line: selected.statement.startLine,
-                    anchor: selected.statement.anchor,
-                    owner: selected.statement.owner,
-                    statement: selected.statement.text,
-                };
-                emitStaticCollection(collection, 'mapping', gate, null, importsByPath.get(collection.path) ?? new Map(), records);
-            }
-            else {
-                let registration = null;
-                for (let index = 0; index < applicableStatements.length && !registration; index += 1) {
-                    registration = registrationListGate(applicableStatements, index, binding);
-                }
-                registration ??= interproceduralIterationGate(applicableStatements, binding, collection.collectionKind);
-                if (registration) {
-                    emitStaticCollection(collection, 'registration', registration.gate, registration.variables, importsByPath.get(collection.path) ?? new Map(), records);
-                }
-                else {
-                    const statement = applicableStatements.find((candidate) => choiceListGate(candidate, binding));
-                    const generated = generatedChoiceGate(applicableStatements, binding);
-                    if (!statement && !generated)
-                        continue;
-                    const choiceGate = generated ?? {
-                        path: statement.path,
-                        line: statement.startLine,
-                        anchor: statement.anchor,
-                        owner: statement.owner,
-                        statement: statement.text,
-                    };
-                    emitStaticCollection(collection, 'choice', choiceGate, null, importsByPath.get(collection.path) ?? new Map(), records);
-                }
-            }
-            emittedCollections.add(identity);
-        }
-    }
-    scanInstallManifests(repositoryRoot, paths, sources, aliases, records);
-    const pascalPaths = paths.filter((path) => ['.inc', '.pas', '.pp'].includes(extname(path).toLowerCase())
-        && !isTestPath(path)
-        && canonicalCopiedPath(path, aliases) === path);
-    for (const path of pascalPaths) {
-        const source = sources.get(path);
-        if (source)
-            statementsByPath.set(path, pascalStatements(path, source));
-    }
-    const rootsByPath = new Map();
-    for (const path of pythonPaths) {
-        rootsByPath.set(path, pythonMaterializationRoots(path, statementsByPath.get(path) ?? [], paths, modulePaths, aliases));
-    }
-    for (const path of pascalPaths) {
-        rootsByPath.set(path, pascalMaterializationRoots(path, statementsByPath.get(path) ?? [], paths, aliases));
-    }
-    emitResourceProviders(paths, statementsByPath, rootsByPath, importsByPath, aliases, records);
-    const bySemanticKey = new Map();
-    records.forEach((record) => bySemanticKey.set(record.semanticIdentityKey, record));
-    return [...bySemanticKey.values()].sort((left, right) => left.path.localeCompare(right.path)
-        || left.line - right.line
-        || left.kind.localeCompare(right.kind)
-        || left.semanticIdentityKey.localeCompare(right.semanticIdentityKey));
-}