@haystackeditor/cli 0.25.1 → 0.26.0

package/dist/commands/cloud-verifier-pascal-selector-census.js

@@ -1,1382 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFileSync, statSync } from 'node:fs';
-import { basename, extname, join, posix } from 'node:path';
-const MAX_PASCAL_SOURCE_BYTES = 4 * 1024 * 1024;
-const PASCAL_EXTENSIONS = new Set(['.pas', '.pp', '.inc']);
-const TEST_COMPONENTS = new Set([
-    '__fixtures__', '__tests__', 'benchmark', 'benchmarks', 'example', 'examples',
-    'fixture', 'fixtures', 'sample', 'samples', 'spec', 'specs', 'test', 'testapp',
-    'testapps', 'tests',
-]);
-const ROUTINE_KEYWORDS = new Set(['constructor', 'destructor', 'function', 'operator', 'procedure']);
-const END_BLOCK_KEYWORDS = new Set(['asm', 'begin', 'case', 'try']);
-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(path) {
-    return path.split(posix.sep).join('/').replace(/^\.\//, '');
-}
-function isTestRoot(path) {
-    const normalized = normalizePath(path);
-    const components = normalized.toLowerCase().split('/');
-    const name = basename(normalized).toLowerCase();
-    return components.slice(0, -1).some((component) => TEST_COMPONENTS.has(component))
-        || /(?:^|[._-])(test|tests|spec|fixture|mock)(?:[._-]|$)/.test(name)
-        || /^(?:test_|conftest\.)/.test(name);
-}
-/** Strip Pascal comments and compiler directives without moving any source. */
-function stripPascalComments(source) {
-    const output = [...source];
-    let index = 0;
-    let mode = 'code';
-    while (index < source.length) {
-        const char = source[index];
-        const next = source[index + 1] ?? '';
-        if (mode === 'code') {
-            if (char === "'") {
-                mode = 'string';
-                index += 1;
-                continue;
-            }
-            if (char === '{')
-                mode = 'brace';
-            else if (char === '(' && next === '*')
-                mode = 'paren-star';
-            else if (char === '/' && next === '/')
-                mode = 'line';
-            else {
-                index += 1;
-                continue;
-            }
-            output[index] = ' ';
-            if (mode === 'paren-star' || mode === 'line')
-                output[index + 1] = ' ';
-            index += mode === 'brace' ? 1 : 2;
-            continue;
-        }
-        if (mode === 'string') {
-            if (char === "'" && next === "'") {
-                index += 2;
-                continue;
-            }
-            if (char === "'")
-                mode = 'code';
-            index += 1;
-            continue;
-        }
-        if (char !== '\n' && char !== '\r')
-            output[index] = ' ';
-        if (mode === 'brace' && char === '}')
-            mode = 'code';
-        else if (mode === 'paren-star' && char === '*' && next === ')') {
-            output[index + 1] = ' ';
-            mode = 'code';
-            index += 2;
-            continue;
-        }
-        else if (mode === 'line' && (char === '\n' || char === '\r'))
-            mode = 'code';
-        index += 1;
-    }
-    return output.join('');
-}
-function tokenizePascal(source) {
-    const clean = stripPascalComments(source);
-    const tokens = [];
-    let line = 1;
-    let index = 0;
-    while (index < clean.length) {
-        const char = clean[index];
-        if (/\s/.test(char)) {
-            if (char === '\n')
-                line += 1;
-            index += 1;
-            continue;
-        }
-        const start = index;
-        const tokenLine = line;
-        if (/[A-Za-z_]/.test(char)) {
-            index += 1;
-            while (index < clean.length && /[A-Za-z0-9_]/.test(clean[index]))
-                index += 1;
-            const text = source.slice(start, index);
-            tokens.push({ text, lower: text.toLowerCase(), kind: 'identifier', start, end: index, line: tokenLine });
-            continue;
-        }
-        if (/\d/.test(char) || (char === '$' && /[0-9A-Fa-f]/.test(clean[index + 1] ?? ''))) {
-            index += 1;
-            while (index < clean.length && /[A-Za-z0-9_.]/.test(clean[index])) {
-                if (clean[index] === '.' && clean[index + 1] === '.')
-                    break;
-                index += 1;
-            }
-            const text = source.slice(start, index);
-            tokens.push({ text, lower: text.toLowerCase(), kind: 'number', start, end: index, line: tokenLine });
-            continue;
-        }
-        if (char === "'") {
-            index += 1;
-            while (index < clean.length) {
-                if (clean[index] === "'" && clean[index + 1] === "'") {
-                    index += 2;
-                    continue;
-                }
-                if (clean[index] === "'") {
-                    index += 1;
-                    break;
-                }
-                if (clean[index] === '\n')
-                    line += 1;
-                index += 1;
-            }
-            const text = source.slice(start, index);
-            tokens.push({ text, lower: text, kind: 'string', start, end: index, line: tokenLine });
-            continue;
-        }
-        const pair = clean.slice(index, index + 2);
-        const text = ['..', ':=', '<=', '>=', '<>', '+=', '-=', '*=', '/='].includes(pair) ? pair : char;
-        index += text.length;
-        tokens.push({ text, lower: text.toLowerCase(), kind: 'symbol', start, end: index, line: tokenLine });
-    }
-    return tokens;
-}
-function canonicalTokens(tokens) {
-    return tokens.map((token) => `${token.kind}:${token.text.length}:${token.text}`).join('|');
-}
-function compactTokens(tokens) {
-    return tokens.map((token) => token.text).join('');
-}
-function trimWrappingParens(tokens) {
-    let current = tokens;
-    while (current.length >= 2 && current[0].text === '(' && current.at(-1)?.text === ')') {
-        let depth = 0;
-        let wraps = true;
-        for (let index = 0; index < current.length; index += 1) {
-            if (current[index].text === '(')
-                depth += 1;
-            else if (current[index].text === ')')
-                depth -= 1;
-            if (depth === 0 && index < current.length - 1) {
-                wraps = false;
-                break;
-            }
-        }
-        if (!wraps)
-            break;
-        current = current.slice(1, -1);
-    }
-    return current;
-}
-function selectorText(tokens) {
-    const trimmed = trimWrappingParens(tokens);
-    if (trimmed.length === 1 && trimmed[0].kind === 'string') {
-        return trimmed[0].text.slice(1, -1).replace(/''/g, "'");
-    }
-    return compactTokens(trimmed);
-}
-function sourceLine(lines, line) {
-    return lines[line - 1] ?? '';
-}
-function matchingEnd(tokens, start) {
-    const opening = tokens[start]?.lower;
-    if (!END_BLOCK_KEYWORDS.has(opening) && opening !== 'repeat')
-        return null;
-    const stack = [opening];
-    for (let index = start + 1; index < tokens.length; index += 1) {
-        const token = tokens[index].lower;
-        if (token === 'repeat')
-            stack.push(token);
-        else if (END_BLOCK_KEYWORDS.has(token))
-            stack.push(token);
-        else if (token === 'until') {
-            const repeat = stack.lastIndexOf('repeat');
-            if (repeat >= 0)
-                stack.splice(repeat, 1);
-        }
-        else if (token === 'end') {
-            for (let cursor = stack.length - 1; cursor >= 0; cursor -= 1) {
-                if (stack[cursor] !== 'repeat') {
-                    stack.splice(cursor, 1);
-                    break;
-                }
-            }
-        }
-        if (stack.length === 0)
-            return index;
-    }
-    return null;
-}
-function routineDeclarations(tokens) {
-    const declarations = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        if (!ROUTINE_KEYWORDS.has(tokens[index].lower))
-            continue;
-        let nameStart = index + 1;
-        if (tokens[nameStart]?.lower === 'generic')
-            nameStart += 1;
-        const nameTokens = [];
-        for (let cursor = nameStart; cursor < tokens.length; cursor += 1) {
-            const token = tokens[cursor];
-            if (token.text === '(' || token.text === ':' || token.text === ';')
-                break;
-            if (token.kind === 'identifier' || token.text === '.')
-                nameTokens.push(token);
-            else
-                break;
-        }
-        const name = compactTokens(nameTokens);
-        if (!name || !/[A-Za-z_]/.test(name[0]))
-            continue;
-        let paren = 0;
-        let headerEnd = -1;
-        for (let cursor = nameStart; cursor < tokens.length; cursor += 1) {
-            if (tokens[cursor].text === '(')
-                paren += 1;
-            else if (tokens[cursor].text === ')')
-                paren -= 1;
-            else if (tokens[cursor].text === ';' && paren === 0) {
-                headerEnd = cursor;
-                break;
-            }
-        }
-        if (headerEnd >= 0)
-            declarations.push({ name, token: index, headerEnd });
-    }
-    return declarations;
-}
-function routineRanges(tokens) {
-    const declarations = routineDeclarations(tokens);
-    const ranges = [];
-    for (let declarationIndex = declarations.length - 1; declarationIndex >= 0; declarationIndex -= 1) {
-        const declaration = declarations[declarationIndex];
-        for (let cursor = declaration.headerEnd + 1; cursor < tokens.length; cursor += 1) {
-            if (tokens[cursor].lower !== 'begin' && tokens[cursor].lower !== 'asm')
-                continue;
-            if (ranges.some((range) => cursor >= range.start && cursor <= range.end))
-                continue;
-            const end = matchingEnd(tokens, cursor);
-            if (end === null)
-                break;
-            ranges.push({ name: declaration.name, declaration: declaration.token, start: cursor, end });
-            break;
-        }
-    }
-    return ranges;
-}
-function ownerAt(tokenIndex, routines) {
-    const containing = routines
-        .filter((routine) => tokenIndex >= routine.start && tokenIndex <= routine.end)
-        .sort((left, right) => (left.end - left.start) - (right.end - right.start)
-        || right.declaration - left.declaration);
-    return containing[0]?.name ?? '<unit-scope>';
-}
-function isInsideDeclarationRecord(tokens, tokenIndex) {
-    // A variant declaration lives between its `record`/`object` opener and any
-    // executable `begin`. Looking only to the nearest such opener avoids trying
-    // to balance conditional-compilation alternatives that are intentionally
-    // retained by the lexical pass.
-    for (let index = tokenIndex - 1; index >= 0; index -= 1) {
-        if (tokens[index].lower === 'begin' || tokens[index].lower === 'asm')
-            return false;
-        if (tokens[index].lower === 'record' || tokens[index].lower === 'object')
-            return true;
-    }
-    return false;
-}
-function topLevelOf(tokens, caseIndex) {
-    let paren = 0;
-    let bracket = 0;
-    for (let index = caseIndex + 1; index < tokens.length; index += 1) {
-        const text = tokens[index].text;
-        if (text === '(')
-            paren += 1;
-        else if (text === ')')
-            paren -= 1;
-        else if (text === '[')
-            bracket += 1;
-        else if (text === ']')
-            bracket -= 1;
-        else if (paren === 0 && bracket === 0 && tokens[index].lower === 'of')
-            return index;
-        else if (paren === 0 && bracket === 0 && (text === ';' || tokens[index].lower === 'end'))
-            return null;
-    }
-    return null;
-}
-function splitLabels(tokens) {
-    const result = [];
-    let start = 0;
-    let paren = 0;
-    let bracket = 0;
-    for (let index = 0; index <= tokens.length; index += 1) {
-        const token = tokens[index];
-        if (token?.text === '(')
-            paren += 1;
-        else if (token?.text === ')')
-            paren -= 1;
-        else if (token?.text === '[')
-            bracket += 1;
-        else if (token?.text === ']')
-            bracket -= 1;
-        if (index === tokens.length || (token?.text === ',' && paren === 0 && bracket === 0)) {
-            const part = tokens.slice(start, index);
-            if (part.length === 0)
-                return null;
-            result.push(part);
-            start = index + 1;
-        }
-    }
-    return result;
-}
-function plausibleCaseLabels(tokens) {
-    if (tokens.length === 0 || tokens.some((token) => token.text === ':=' || token.text === ';'))
-        return false;
-    const forbidden = new Set([
-        'begin', 'case', 'do', 'else', 'end', 'for', 'if', 'repeat', 'then', 'try', 'until', 'while', 'with',
-    ]);
-    return !tokens.some((token) => token.kind === 'identifier' && forbidden.has(token.lower));
-}
-function caseBranches(source, lines, tokens, caseIndex, ofIndex, endIndex) {
-    const candidates = [];
-    const stack = ['case'];
-    let segmentStart = ofIndex + 1;
-    let caseElseIndex = null;
-    let pendingTopLevelIf = 0;
-    for (let index = ofIndex + 1; index < endIndex; index += 1) {
-        const token = tokens[index];
-        const lower = token.lower;
-        if (lower === 'repeat')
-            stack.push(lower);
-        else if (END_BLOCK_KEYWORDS.has(lower))
-            stack.push(lower);
-        else if (lower === 'until') {
-            const repeat = stack.lastIndexOf('repeat');
-            if (repeat >= 0)
-                stack.splice(repeat, 1);
-        }
-        else if (lower === 'end') {
-            for (let cursor = stack.length - 1; cursor > 0; cursor -= 1) {
-                if (stack[cursor] !== 'repeat') {
-                    stack.splice(cursor, 1);
-                    break;
-                }
-            }
-        }
-        if (stack.length !== 1)
-            continue;
-        if (lower === 'if') {
-            pendingTopLevelIf += 1;
-            continue;
-        }
-        if (token.text === ';') {
-            segmentStart = index + 1;
-            pendingTopLevelIf = 0;
-            continue;
-        }
-        if (lower === 'else' && pendingTopLevelIf > 0) {
-            pendingTopLevelIf -= 1;
-            continue;
-        }
-        if (lower === 'else') {
-            caseElseIndex = index;
-            break;
-        }
-        if (token.text !== ':')
-            continue;
-        const labelTokens = tokens.slice(segmentStart, index);
-        if (!plausibleCaseLabels(labelTokens))
-            continue;
-        const labels = splitLabels(labelTokens);
-        if (!labels)
-            continue;
-        candidates.push({ colon: index, start: segmentStart, labels });
-    }
-    const branches = [];
-    candidates.forEach((candidate, index) => {
-        const bodyStart = candidate.colon + 1;
-        let bodyEnd = index + 1 < candidates.length
-            ? candidates[index + 1].start
-            : caseElseIndex ?? endIndex;
-        for (let cursor = bodyEnd - 1; cursor >= bodyStart; cursor -= 1) {
-            if (tokens[cursor].lower === 'else' && cursor < endIndex)
-                bodyEnd = cursor;
-            if (tokens[cursor].text !== ';')
-                break;
-            bodyEnd = cursor;
-        }
-        const body = tokens.slice(bodyStart, bodyEnd);
-        if (body.length === 0)
-            return;
-        const implementationHash = sha256(canonicalTokens(body)).slice(0, 24);
-        branches.push({
-            labelTokens: candidate.labels,
-            bodyStart,
-            bodyEnd,
-            line: tokens[candidate.start]?.line ?? tokens[caseIndex].line,
-            anchor: sourceLine(lines, tokens[candidate.start]?.line ?? tokens[caseIndex].line),
-            implementationKey: `pascal-branch:${implementationHash}`,
-            entryIdentities: [],
-        });
-    });
-    return {
-        branches,
-        hasElse: caseElseIndex !== null && caseElseIndex + 1 < endIndex,
-        elseBodyStart: caseElseIndex === null ? null : caseElseIndex + 1,
-        elseBodyEnd: caseElseIndex === null ? null : endIndex,
-    };
-}
-function closedDomains(tokens) {
-    const domains = new Map([
-        ['boolean', new Set(['false', 'true'])],
-        ['bool', new Set(['false', 'true'])],
-    ]);
-    for (let index = 0; index < tokens.length - 4; index += 1) {
-        if (tokens[index].kind !== 'identifier' || tokens[index + 1].text !== '=' || tokens[index + 2].text !== '(')
-            continue;
-        const values = [];
-        let valid = true;
-        let cursor = index + 3;
-        while (cursor < tokens.length && tokens[cursor].text !== ')') {
-            if (tokens[cursor].kind !== 'identifier') {
-                valid = false;
-                break;
-            }
-            values.push(tokens[cursor].lower);
-            cursor += 1;
-            if (tokens[cursor]?.text === '=') {
-                cursor += 1;
-                if (tokens[cursor]?.text === '+' || tokens[cursor]?.text === '-')
-                    cursor += 1;
-                if (tokens[cursor]?.kind !== 'number') {
-                    valid = false;
-                    break;
-                }
-                cursor += 1;
-            }
-            if (tokens[cursor]?.text === ',')
-                cursor += 1;
-            else if (tokens[cursor]?.text !== ')') {
-                valid = false;
-                break;
-            }
-        }
-        if (valid && values.length > 0 && tokens[cursor]?.text === ')' && tokens[cursor + 1]?.text === ';') {
-            domains.set(tokens[index].lower, new Set(values));
-        }
-    }
-    return domains;
-}
-function containingRoutine(tokenIndex, routines) {
-    return routines
-        .filter((routine) => tokenIndex >= routine.start && tokenIndex <= routine.end)
-        .sort((left, right) => (left.end - left.start) - (right.end - right.start)
-        || right.declaration - left.declaration)[0] ?? null;
-}
-function closedDomainForCase(subjectTokens, caseIndex, tokens, routines, domains) {
-    const subject = trimWrappingParens(subjectTokens);
-    if (subject.length >= 4 && subject[0].kind === 'identifier' && subject[1].text === '('
-        && subject.at(-1)?.text === ')' && domains.has(subject[0].lower))
-        return { typeName: subject[0].text, values: domains.get(subject[0].lower) };
-    if (subject.length !== 1 || subject[0].kind !== 'identifier')
-        return null;
-    const routine = containingRoutine(caseIndex, routines);
-    const searchStart = routine?.declaration ?? 0;
-    for (let colon = caseIndex - 2; colon >= searchStart; colon -= 1) {
-        if (tokens[colon].text !== ':' || tokens[colon + 1]?.kind !== 'identifier')
-            continue;
-        const values = domains.get(tokens[colon + 1].lower);
-        if (!values || ![';', ')', '=', ','].includes(tokens[colon + 2]?.text ?? ''))
-            continue;
-        const names = [];
-        for (let cursor = colon - 1; cursor >= searchStart; cursor -= 1) {
-            const token = tokens[cursor];
-            if (token.text === ';' || token.text === '(' || ['var', 'const', 'out', 'type'].includes(token.lower))
-                break;
-            if (token.kind === 'identifier')
-                names.push(token);
-            else if (token.text !== ',')
-                break;
-        }
-        if (names.some((name) => name.lower === subject[0].lower)) {
-            return { typeName: tokens[colon + 1].text, values };
-        }
-    }
-    return null;
-}
-function branchLabelsCoverDomain(branches, domain) {
-    const labels = branches.flatMap((branch) => branch.labelTokens).map((label) => {
-        const value = selectorText(label).toLowerCase();
-        return value.includes('.') ? value.split('.').at(-1) : value;
-    });
-    return labels.every((label) => domain.has(label)) && domain.size === new Set(labels).size;
-}
-function pureBooleanOutcome(tokens, start, end) {
-    let body = tokens.slice(start, end).filter((token) => token.text !== ';');
-    while (body[0]?.lower === 'begin' && body.at(-1)?.lower === 'end') {
-        body = body.slice(1, -1).filter((token) => token.text !== ';');
-    }
-    if (body.length === 3
-        && body[0].kind === 'identifier'
-        && body[1].text === ':='
-        && (body[2].lower === 'false' || body[2].lower === 'true'))
-        return body[2].lower;
-    if (body.length === 4
-        && body[0].lower === 'exit'
-        && body[1].text === '('
-        && (body[2].lower === 'false' || body[2].lower === 'true')
-        && body[3].text === ')')
-        return body[2].lower;
-    return null;
-}
-function isBooleanMembershipCase(parsed, tokens) {
-    if (parsed.branches.length === 0
-        || parsed.elseBodyStart === null
-        || parsed.elseBodyEnd === null)
-        return false;
-    const branchOutcomes = parsed.branches.map((branch) => pureBooleanOutcome(tokens, branch.bodyStart, branch.bodyEnd));
-    const fallback = pureBooleanOutcome(tokens, parsed.elseBodyStart, parsed.elseBodyEnd);
-    return fallback !== null
-        && branchOutcomes.every((outcome) => outcome !== null && outcome !== fallback);
-}
-function scanCaseFamilies(path, source, lines, tokens, routines) {
-    const partial = [];
-    const domains = closedDomains(tokens);
-    for (let index = 0; index < tokens.length; index += 1) {
-        if (tokens[index].lower !== 'case' || isInsideDeclarationRecord(tokens, index))
-            continue;
-        const ofIndex = topLevelOf(tokens, index);
-        if (ofIndex === null)
-            continue;
-        const subjectTokens = tokens.slice(index + 1, ofIndex);
-        if (subjectTokens.length === 0 || subjectTokens.some((token) => token.text === ':'))
-            continue;
-        const end = matchingEnd(tokens, index);
-        if (end === null)
-            continue;
-        const parsed = caseBranches(source, lines, tokens, index, ofIndex, end);
-        const domain = parsed.branches.length === 1
-            ? closedDomainForCase(subjectTokens, index, tokens, routines, domains)
-            : null;
-        const exactOneArm = domain !== null
-            && (parsed.hasElse || branchLabelsCoverDomain(parsed.branches, domain.values));
-        const exhaustiveFallback = parsed.branches.length === 1
-            && parsed.elseBodyStart !== null && parsed.elseBodyEnd !== null
-            && sha256(canonicalTokens(tokens.slice(parsed.elseBodyStart, parsed.elseBodyEnd)))
-                !== sha256(canonicalTokens(tokens.slice(parsed.branches[0].bodyStart, parsed.branches[0].bodyEnd)));
-        const booleanMembership = isBooleanMembershipCase(parsed, tokens);
-        const discoveryLead = booleanMembership
-            || (parsed.branches.length === 1 && !exactOneArm && !exhaustiveFallback);
-        if (parsed.branches.length === 0)
-            continue;
-        const owner = ownerAt(index, routines);
-        partial.push({
-            kind: discoveryLead ? 'pascal-case-membership-lead-family' : 'pascal-typed-case-family',
-            entryKind: discoveryLead ? 'pascal-case-membership-lead-entry' : 'pascal-typed-case-entry',
-            path,
-            owner,
-            selectorSubject: compactTokens(subjectTokens),
-            ...(domain === null ? {} : {
-                selectorDomainIdentity: `closed-domain:${domain.typeName}:${compactTokens(subjectTokens)}`,
-            }),
-            proofStatus: discoveryLead ? 'discovery-lead' : 'proof-complete',
-            line: tokens[index].line,
-            anchor: sourceLine(lines, tokens[index].line),
-            start: index,
-            end,
-            branches: parsed.branches,
-        });
-    }
-    const occurrences = new Map();
-    return partial.map((family) => {
-        const signature = sha256(canonicalTokens(tokens.slice(family.start, family.end + 1))).slice(0, 24);
-        const base = `${family.owner}\0${family.selectorSubject}\0${signature}`;
-        const occurrence = (occurrences.get(base) ?? 0) + 1;
-        occurrences.set(base, occurrence);
-        return { ...family, identity: `pascal-case:${family.selectorSubject}:${signature}:${occurrence}` };
-    });
-}
-function statementEnd(tokens, start) {
-    if (start >= tokens.length)
-        return start;
-    const blockEnd = matchingEnd(tokens, start);
-    if (blockEnd !== null)
-        return blockEnd + (tokens[blockEnd + 1]?.text === ';' ? 2 : 1);
-    let paren = 0;
-    let bracket = 0;
-    for (let index = start; index < tokens.length; index += 1) {
-        if (tokens[index].text === '(')
-            paren += 1;
-        else if (tokens[index].text === ')')
-            paren -= 1;
-        else if (tokens[index].text === '[')
-            bracket += 1;
-        else if (tokens[index].text === ']')
-            bracket -= 1;
-        else if (tokens[index].lower === 'else' && paren === 0 && bracket === 0)
-            return index;
-        else if (tokens[index].text === ';' && paren === 0 && bracket === 0)
-            return index + 1;
-    }
-    return tokens.length;
-}
-function topLevelThen(tokens, ifIndex) {
-    let paren = 0;
-    let bracket = 0;
-    for (let index = ifIndex + 1; index < tokens.length; index += 1) {
-        if (tokens[index].text === '(')
-            paren += 1;
-        else if (tokens[index].text === ')')
-            paren -= 1;
-        else if (tokens[index].text === '[')
-            bracket += 1;
-        else if (tokens[index].text === ']')
-            bracket -= 1;
-        else if (tokens[index].lower === 'then' && paren === 0 && bracket === 0)
-            return index;
-        else if (tokens[index].text === ';' && paren === 0 && bracket === 0)
-            return null;
-    }
-    return null;
-}
-function simpleQualifiedReference(tokens, allowAddress = false) {
-    const trimmed = trimWrappingParens(tokens);
-    let index = allowAddress && trimmed[0]?.text === '@' ? 1 : 0;
-    if (trimmed[index]?.kind !== 'identifier')
-        return false;
-    index += 1;
-    while (index < trimmed.length) {
-        if (trimmed[index].text !== '.' || trimmed[index + 1]?.kind !== 'identifier')
-            return false;
-        index += 2;
-    }
-    return true;
-}
-function exactLiteral(tokens) {
-    const trimmed = trimWrappingParens(tokens);
-    if (trimmed.length === 1) {
-        return trimmed[0].kind === 'string' || trimmed[0].kind === 'number'
-            || ['false', 'nil', 'true'].includes(trimmed[0].lower);
-    }
-    return trimmed.length >= 2 && trimmed.every((token) => token.kind === 'number' || token.text === '#' || token.text === '+' || token.text === '-');
-}
-function splitTopLevelOr(tokens) {
-    const condition = trimWrappingParens(tokens);
-    const clauses = [];
-    let start = 0;
-    let paren = 0;
-    let bracket = 0;
-    for (let index = 0; index <= condition.length; index += 1) {
-        const token = condition[index];
-        if (token?.text === '(')
-            paren += 1;
-        else if (token?.text === ')')
-            paren -= 1;
-        else if (token?.text === '[')
-            bracket += 1;
-        else if (token?.text === ']')
-            bracket -= 1;
-        if (index === condition.length || (token?.lower === 'or' && paren === 0 && bracket === 0)) {
-            clauses.push(condition.slice(start, index));
-            start = index + 1;
-        }
-    }
-    return clauses;
-}
-function sliceCallArguments(tokens, open) {
-    const result = [];
-    let start = open + 1;
-    let paren = 1;
-    let bracket = 0;
-    for (let index = open + 1; index < tokens.length; index += 1) {
-        if (tokens[index].text === '(')
-            paren += 1;
-        else if (tokens[index].text === ')') {
-            paren -= 1;
-            if (paren === 0) {
-                if (index !== tokens.length - 1)
-                    return null;
-                result.push(tokens.slice(start, index));
-                return result;
-            }
-        }
-        else if (tokens[index].text === '[')
-            bracket += 1;
-        else if (tokens[index].text === ']')
-            bracket -= 1;
-        else if (tokens[index].text === ',' && paren === 1 && bracket === 0) {
-            result.push(tokens.slice(start, index));
-            start = index + 1;
-        }
-    }
-    return null;
-}
-function exactEqualityClause(tokens) {
-    const clause = trimWrappingParens(tokens);
-    let paren = 0;
-    let bracket = 0;
-    let operator = -1;
-    for (let index = 0; index < clause.length; index += 1) {
-        if (clause[index].text === '(')
-            paren += 1;
-        else if (clause[index].text === ')')
-            paren -= 1;
-        else if (clause[index].text === '[')
-            bracket += 1;
-        else if (clause[index].text === ']')
-            bracket -= 1;
-        else if (clause[index].text === '=' && paren === 0 && bracket === 0) {
-            if (operator >= 0)
-                return null;
-            operator = index;
-        }
-    }
-    if (operator <= 0 || operator >= clause.length - 1)
-        return null;
-    const subject = clause.slice(0, operator);
-    const selector = clause.slice(operator + 1);
-    if (!simpleQualifiedReference(subject) || !exactLiteral(selector))
-        return null;
-    return { subject: compactTokens(subject), selectors: [selectorText(selector)] };
-}
-const SUBJECT_FIRST_PREFIX_PREDICATES = new Set([
-    'beginswith', 'sbeginswith', 'sstartswith', 'startswith',
-]);
-const PREFIX_FIRST_PREDICATES = new Set([
-    'ansistartsstr', 'ansistartstext', 'startsstr', 'startstext',
-]);
-const RECEIVER_PREFIX_PREDICATES = new Set(['beginswith', 'startswith']);
-function exactPrefixClause(tokens) {
-    const clause = trimWrappingParens(tokens);
-    const open = clause.findIndex((token) => token.text === '(');
-    if (open < 1 || clause.at(-1)?.text !== ')')
-        return null;
-    const args = sliceCallArguments(clause, open);
-    if (!args)
-        return null;
-    const callee = clause.slice(0, open);
-    if (callee.length >= 3 && callee.at(-2)?.text === '.') {
-        const method = callee.at(-1);
-        const receiver = callee.slice(0, -2);
-        if (method.kind === 'identifier' && RECEIVER_PREFIX_PREDICATES.has(method.lower)
-            && simpleQualifiedReference(receiver) && args.length === 1 && exactLiteral(args[0]))
-            return { subject: compactTokens(receiver), selectors: [`${selectorText(args[0])}*`] };
-        return null;
-    }
-    if (callee.length !== 1 || callee[0].kind !== 'identifier' || args.length !== 2)
-        return null;
-    if (SUBJECT_FIRST_PREFIX_PREDICATES.has(callee[0].lower)
-        && simpleQualifiedReference(args[0]) && exactLiteral(args[1]))
-        return { subject: compactTokens(trimWrappingParens(args[0])), selectors: [`${selectorText(args[1])}*`] };
-    if (PREFIX_FIRST_PREDICATES.has(callee[0].lower)
-        && exactLiteral(args[0]) && simpleQualifiedReference(args[1]))
-        return { subject: compactTokens(trimWrappingParens(args[1])), selectors: [`${selectorText(args[0])}*`] };
-    return null;
-}
-function equalityCondition(tokens) {
-    const clauses = splitTopLevelOr(tokens);
-    const parsed = clauses.map((clause) => exactEqualityClause(clause) ?? exactPrefixClause(clause));
-    if (parsed.some((clause) => clause === null))
-        return null;
-    const exact = parsed;
-    if (exact.length === 0 || exact.some((clause) => clause.subject !== exact[0].subject))
-        return null;
-    return { subject: exact[0].subject, selectors: [...new Set(exact.flatMap((clause) => clause.selectors))] };
-}
-function runtimeTypeCondition(tokens) {
-    const condition = trimWrappingParens(tokens);
-    const operator = condition.findIndex((token) => token.lower === 'is');
-    if (operator <= 0 || operator >= condition.length - 1)
-        return null;
-    if (condition.slice(operator + 1).some((token) => token.lower === 'is'))
-        return null;
-    const subject = condition.slice(0, operator);
-    const selector = condition.slice(operator + 1);
-    if (!simpleQualifiedReference(subject) || !simpleQualifiedReference(selector))
-        return null;
-    return { subject: compactTokens(subject), selectors: [compactTokens(selector)] };
-}
-function conditionalOccurrences(tokens, routines) {
-    const result = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        if (tokens[index].lower !== 'if' || isInsideDeclarationRecord(tokens, index))
-            continue;
-        const then = topLevelThen(tokens, index);
-        if (then === null)
-            continue;
-        const bodyStart = then + 1;
-        const bodyEnd = statementEnd(tokens, bodyStart);
-        if (bodyEnd <= bodyStart)
-            continue;
-        const elseToken = tokens[bodyEnd]?.lower === 'else' ? bodyEnd : null;
-        const elseStart = elseToken === null ? null : elseToken + 1;
-        const elseEnd = elseStart === null ? null : statementEnd(tokens, elseStart);
-        result.push({
-            start: index,
-            bodyStart,
-            bodyEnd,
-            elseStart,
-            elseEnd,
-            fullEnd: elseEnd ?? bodyEnd,
-            owner: ownerAt(index, routines),
-            typeCondition: runtimeTypeCondition(tokens.slice(index + 1, then)),
-            equalityCondition: equalityCondition(tokens.slice(index + 1, then)),
-        });
-    }
-    return result;
-}
-function rawCaseRegions(source, lines, tokens) {
-    const result = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        if (tokens[index].lower !== 'case' || isInsideDeclarationRecord(tokens, index))
-            continue;
-        const of = topLevelOf(tokens, index);
-        const end = of === null ? null : matchingEnd(tokens, index);
-        if (of === null || end === null)
-            continue;
-        const parsed = caseBranches(source, lines, tokens, index, of, end);
-        parsed.branches.forEach((branch) => result.push({ start: branch.bodyStart, end: branch.bodyEnd }));
-    }
-    return result;
-}
-function enclosingRegion(occurrence, subject, mode, occurrences, caseRegions, routines, tokenCount) {
-    const candidates = [...caseRegions.filter((region) => occurrence.start > region.start && occurrence.start < region.end)];
-    occurrences.forEach((parent) => {
-        if (parent === occurrence)
-            return;
-        const sameDispatch = mode === 'type'
-            ? parent.typeCondition?.subject === subject
-            : parent.equalityCondition?.subject === subject;
-        if (sameDispatch)
-            return;
-        const regions = [
-            { start: parent.bodyStart, end: parent.bodyEnd },
-            ...(parent.elseStart === null || parent.elseEnd === null
-                ? [] : [{ start: parent.elseStart, end: parent.elseEnd }]),
-        ];
-        regions.forEach((region) => {
-            if (occurrence.start > region.start && occurrence.start < region.end)
-                candidates.push(region);
-        });
-    });
-    const routine = containingRoutine(occurrence.start, routines);
-    candidates.push(routine ? { start: routine.start, end: routine.end } : { start: -1, end: tokenCount });
-    return candidates.sort((left, right) => (left.end - left.start) - (right.end - right.start))[0];
-}
-function onlySeparators(tokens, start, end) {
-    return tokens.slice(start, end).every((token) => token.text === ';');
-}
-function clusterOccurrences(entries, tokens) {
-    const sorted = [...entries].sort((left, right) => left.start - right.start);
-    const result = [];
-    let current = [];
-    let coveredUntil = -1;
-    sorted.forEach((entry) => {
-        if (current.length === 0 || entry.start <= coveredUntil || onlySeparators(tokens, coveredUntil, entry.start)) {
-            current.push(entry);
-            coveredUntil = Math.max(coveredUntil, entry.fullEnd);
-            return;
-        }
-        result.push(current);
-        current = [entry];
-        coveredUntil = entry.fullEnd;
-    });
-    if (current.length > 0)
-        result.push(current);
-    return result;
-}
-function statementTerminates(tokens, start, end) {
-    const terminal = new Set(['abort', 'break', 'continue', 'exit', 'halt', 'raise']);
-    while (start < end && tokens[start]?.text === ';')
-        start += 1;
-    while (end > start && tokens[end - 1]?.text === ';')
-        end -= 1;
-    if (start >= end)
-        return false;
-    if (terminal.has(tokens[start].lower))
-        return true;
-    if (tokens[start].lower === 'begin') {
-        const blockEnd = matchingEnd(tokens, start);
-        if (blockEnd === null || blockEnd >= end)
-            return false;
-        const statements = [];
-        const stack = ['begin'];
-        let statementStart = start + 1;
-        for (let index = start + 1; index < blockEnd; index += 1) {
-            const lower = tokens[index].lower;
-            if (lower === 'repeat')
-                stack.push(lower);
-            else if (END_BLOCK_KEYWORDS.has(lower))
-                stack.push(lower);
-            else if (lower === 'until') {
-                const repeat = stack.lastIndexOf('repeat');
-                if (repeat >= 0)
-                    stack.splice(repeat, 1);
-            }
-            else if (lower === 'end') {
-                for (let cursor = stack.length - 1; cursor > 0; cursor -= 1) {
-                    if (stack[cursor] !== 'repeat') {
-                        stack.splice(cursor, 1);
-                        break;
-                    }
-                }
-            }
-            if (stack.length === 1 && tokens[index].text === ';') {
-                if (statementStart < index)
-                    statements.push({ start: statementStart, end: index });
-                statementStart = index + 1;
-            }
-        }
-        if (statementStart < blockEnd)
-            statements.push({ start: statementStart, end: blockEnd });
-        const last = statements.at(-1);
-        return last !== undefined && statementTerminates(tokens, last.start, last.end);
-    }
-    if (tokens[start].lower === 'if') {
-        const then = topLevelThen(tokens, start);
-        if (then === null || then >= end)
-            return false;
-        const thenStart = then + 1;
-        const thenEnd = statementEnd(tokens, thenStart);
-        if (thenEnd >= end || tokens[thenEnd]?.lower !== 'else')
-            return false;
-        const elseStart = thenEnd + 1;
-        const elseEnd = statementEnd(tokens, elseStart);
-        return elseEnd <= end
-            && statementTerminates(tokens, thenStart, thenEnd)
-            && statementTerminates(tokens, elseStart, elseEnd);
-    }
-    return false;
-}
-function terminalBehavior(tokens, start, end) {
-    return statementTerminates(tokens, start, end);
-}
-function safeLinearFallthrough(tokens, start, end) {
-    const control = new Set([
-        'break', 'case', 'continue', 'exit', 'for', 'goto', 'halt', 'if', 'raise',
-        'repeat', 'try', 'while', 'with',
-    ]);
-    return !tokens.slice(start, end).some((token) => control.has(token.lower));
-}
-function structuralRegionBoundary(tokens, start, end) {
-    return tokens.slice(start, end).every((token) => ['.', ')', ';'].includes(token.text) || ['else', 'end'].includes(token.lower));
-}
-function terminalPostdominatorCluster(entries, region, tokens) {
-    const sorted = [...entries].sort((left, right) => left.start - right.start);
-    if (sorted.length < 2 || !sorted.every((entry) => terminalBehavior(tokens, entry.bodyStart, entry.bodyEnd))) {
-        return null;
-    }
-    for (let index = 1; index < sorted.length; index += 1) {
-        if (!safeLinearFallthrough(tokens, sorted[index - 1].fullEnd, sorted[index].start))
-            return null;
-    }
-    const last = sorted.at(-1);
-    const exactFallback = structuralRegionBoundary(tokens, last.fullEnd, region.end)
-        || statementTerminates(tokens, last.fullEnd, region.end);
-    return exactFallback ? sorted : null;
-}
-function elseConnected(entries) {
-    return entries.some((parent) => parent.elseStart !== null && parent.elseEnd !== null && entries.some((child) => child !== parent && child.start >= parent.elseStart && child.start < parent.elseEnd));
-}
-function scanConditionalFamilies(path, source, lines, tokens, routines) {
-    const result = [];
-    const allOccurrences = conditionalOccurrences(tokens, routines);
-    const caseRegions = rawCaseRegions(source, lines, tokens);
-    for (const mode of ['type', 'equality']) {
-        const occurrences = new Map();
-        const groups = new Map();
-        const regions = new Map();
-        allOccurrences.forEach((entry) => {
-            const condition = mode === 'type' ? entry.typeCondition : entry.equalityCondition;
-            if (!condition)
-                return;
-            const region = enclosingRegion(entry, condition.subject, mode, allOccurrences, caseRegions, routines, tokens.length);
-            const key = `${entry.owner}\0${region.start}:${region.end}\0${condition.subject}`;
-            const values = groups.get(key) ?? [];
-            values.push(entry);
-            groups.set(key, values);
-            regions.set(key, region);
-        });
-        groups.forEach((group, groupKey) => {
-            const adjacency = clusterOccurrences(group, tokens);
-            const terminalCluster = mode === 'type'
-                ? terminalPostdominatorCluster(group, regions.get(groupKey), tokens)
-                : null;
-            const candidateGroups = mode === 'equality'
-                ? adjacency
-                : [
-                    ...adjacency.filter((entries) => elseConnected(entries)),
-                    ...(terminalCluster === null ? [] : [terminalCluster]),
-                ];
-            const uniqueGroups = [...new Map(candidateGroups.map((entries) => [
-                    entries.map((entry) => entry.start).join(','), entries,
-                ])).values()];
-            uniqueGroups.forEach((entries) => {
-                const conditions = entries.map((entry) => mode === 'type' ? entry.typeCondition : entry.equalityCondition);
-                const selectorCount = new Set(conditions.flatMap((condition) => condition.selectors)).size;
-                const implementations = entries.map((entry) => sha256(canonicalTokens(tokens.slice(entry.bodyStart, entry.bodyEnd))).slice(0, 24));
-                if (selectorCount < 2 || new Set(implementations).size < 2)
-                    return;
-                if (mode === 'type' && !elseConnected(entries) && !entries.every((entry) => terminalBehavior(tokens, entry.bodyStart, entry.bodyEnd)))
-                    return;
-                const owner = entries[0].owner;
-                const subject = conditions[0].subject;
-                const booleanMembership = mode === 'equality'
-                    && entries.every((entry) => pureBooleanOutcome(tokens, entry.bodyStart, entry.bodyEnd) !== null);
-                const kind = booleanMembership
-                    ? 'pascal-conditional-membership-lead-family'
-                    : mode === 'type' ? 'pascal-typed-runtime-type-family' : 'pascal-typed-equality-family';
-                const entryKind = booleanMembership
-                    ? 'pascal-conditional-membership-lead-entry'
-                    : mode === 'type' ? 'pascal-typed-runtime-type-entry' : 'pascal-typed-equality-entry';
-                const signature = sha256(entries.map((entry) => canonicalTokens(tokens.slice(entry.start, entry.bodyEnd))).join('\0')).slice(0, 24);
-                const occurrenceBase = `${owner}\0${subject}\0${signature}`;
-                const occurrence = (occurrences.get(occurrenceBase) ?? 0) + 1;
-                occurrences.set(occurrenceBase, occurrence);
-                result.push({
-                    kind,
-                    entryKind,
-                    path,
-                    owner,
-                    identity: `${mode === 'type' ? 'pascal-is' : 'pascal-equality'}:${subject}:${signature}:${occurrence}`,
-                    selectorSubject: subject,
-                    proofStatus: booleanMembership ? 'discovery-lead' : 'proof-complete',
-                    line: tokens[entries[0].start].line,
-                    anchor: sourceLine(lines, tokens[entries[0].start].line),
-                    start: entries[0].start,
-                    end: entries.at(-1).bodyEnd,
-                    branches: entries.map((entry, entryIndex) => ({
-                        labelTokens: [],
-                        bodyStart: entry.bodyStart,
-                        bodyEnd: entry.bodyEnd,
-                        line: tokens[entry.start].line,
-                        anchor: sourceLine(lines, tokens[entry.start].line),
-                        implementationKey: `pascal-branch:${implementations[entryIndex]}`,
-                        entryIdentities: conditions[entryIndex].selectors,
-                    })),
-                });
-            });
-        });
-    }
-    return result;
-}
-function callArguments(tokens, open) {
-    const args = [];
-    let start = open + 1;
-    let paren = 1;
-    let bracket = 0;
-    for (let index = open + 1; index < tokens.length; index += 1) {
-        if (tokens[index].text === '(')
-            paren += 1;
-        else if (tokens[index].text === ')') {
-            paren -= 1;
-            if (paren === 0) {
-                args.push(tokens.slice(start, index));
-                return { args, end: index };
-            }
-        }
-        else if (tokens[index].text === '[')
-            bracket += 1;
-        else if (tokens[index].text === ']')
-            bracket -= 1;
-        else if (tokens[index].text === ',' && paren === 1 && bracket === 0) {
-            args.push(tokens.slice(start, index));
-            start = index + 1;
-        }
-    }
-    return null;
-}
-function topLevelDo(tokens, withIndex) {
-    let paren = 0;
-    let bracket = 0;
-    for (let index = withIndex + 1; index < tokens.length; index += 1) {
-        if (tokens[index].text === '(')
-            paren += 1;
-        else if (tokens[index].text === ')')
-            paren -= 1;
-        else if (tokens[index].text === '[')
-            bracket += 1;
-        else if (tokens[index].text === ']')
-            bracket -= 1;
-        else if (tokens[index].lower === 'do' && paren === 0 && bracket === 0)
-            return index;
-        else if (tokens[index].text === ';' && paren === 0 && bracket === 0)
-            return null;
-    }
-    return null;
-}
-function exactWithReceiver(tokens) {
-    let paren = 0;
-    let bracket = 0;
-    let asIndex = -1;
-    for (let index = 0; index < tokens.length; index += 1) {
-        if (tokens[index].text === '(')
-            paren += 1;
-        else if (tokens[index].text === ')')
-            paren -= 1;
-        else if (tokens[index].text === '[')
-            bracket += 1;
-        else if (tokens[index].text === ']')
-            bracket -= 1;
-        else if (tokens[index].lower === 'as' && paren === 0 && bracket === 0)
-            asIndex = index;
-    }
-    if (asIndex <= 0 || asIndex >= tokens.length - 1)
-        return null;
-    const expression = tokens.slice(0, asIndex);
-    const type = tokens.slice(asIndex + 1);
-    if (!simpleQualifiedReference(type) || expression.some((token) => [',', ';'].includes(token.text)))
-        return null;
-    return `${compactTokens(expression)} as ${compactTokens(type)}`;
-}
-function withScopes(tokens, routines) {
-    const result = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        if (tokens[index].lower !== 'with')
-            continue;
-        const doIndex = topLevelDo(tokens, index);
-        if (doIndex === null)
-            continue;
-        const receiver = exactWithReceiver(tokens.slice(index + 1, doIndex));
-        if (!receiver)
-            continue;
-        const bodyStart = doIndex + 1;
-        const bodyEnd = statementEnd(tokens, bodyStart);
-        if (bodyEnd <= bodyStart)
-            continue;
-        result.push({ owner: ownerAt(index, routines), receiver, start: index, bodyStart, bodyEnd });
-    }
-    return result;
-}
-function scanAddMethodFamilies(path, source, lines, tokens, routines) {
-    const scopes = withScopes(tokens, routines);
-    const groups = new Map();
-    for (let index = 0; index < tokens.length - 2; index += 1) {
-        if (tokens[index].lower !== 'addmethod' || tokens[index + 1].text !== '(')
-            continue;
-        let receiverStart = index;
-        let receiverIdentity = null;
-        let gateIdentity = '';
-        if (tokens[index - 1]?.text === '.') {
-            receiverStart = index - 2;
-            while (receiverStart >= 2 && tokens[receiverStart - 1].text === '.' && tokens[receiverStart - 2].kind === 'identifier')
-                receiverStart -= 2;
-            const receiver = tokens.slice(receiverStart, index - 1);
-            if (!simpleQualifiedReference(receiver))
-                continue;
-            receiverIdentity = compactTokens(receiver);
-        }
-        else {
-            const scope = scopes
-                .filter((candidate) => index >= candidate.bodyStart && index < candidate.bodyEnd)
-                .sort((left, right) => (left.bodyEnd - left.bodyStart) - (right.bodyEnd - right.bodyStart))[0];
-            if (!scope)
-                continue;
-            receiverStart = index;
-            receiverIdentity = scope.receiver;
-            gateIdentity = `with:${scope.start}`;
-        }
-        const call = callArguments(tokens, index + 1);
-        if (!call || call.args.length < 2 || !exactLiteral(call.args[0]) || !simpleQualifiedReference(call.args[1], true))
-            continue;
-        const owner = ownerAt(index, routines);
-        const groupKey = `${owner}\0${receiverIdentity}\0${gateIdentity}`;
-        const group = groups.get(groupKey) ?? { owner, receiver: receiverIdentity, registrations: [] };
-        group.registrations.push({
-            selector: selectorText(call.args[0]),
-            handler: compactTokens(trimWrappingParens(call.args[1])),
-            line: tokens[index].line,
-            anchor: sourceLine(lines, tokens[index].line),
-            start: receiverStart,
-            end: call.end + 1,
-        });
-        groups.set(groupKey, group);
-    }
-    const result = [];
-    const occurrences = new Map();
-    groups.forEach(({ owner, receiver, registrations }) => {
-        if (registrations.length < 2)
-            return;
-        const signature = sha256(registrations.map((entry) => `${entry.selector}\0${entry.handler}`).join('\0')).slice(0, 24);
-        const occurrenceBase = `${owner}\0${receiver}\0${signature}`;
-        const occurrence = (occurrences.get(occurrenceBase) ?? 0) + 1;
-        occurrences.set(occurrenceBase, occurrence);
-        result.push({
-            kind: 'pascal-typed-method-registration-family',
-            entryKind: 'pascal-typed-method-registration-entry',
-            path,
-            owner,
-            identity: `pascal-add-method:${receiver}:${signature}:${occurrence}`,
-            selectorSubject: receiver,
-            line: registrations[0].line,
-            anchor: registrations[0].anchor,
-            start: registrations[0].start,
-            end: registrations.at(-1).end,
-            branches: registrations.map((registration) => ({
-                labelTokens: [],
-                bodyStart: registration.start,
-                bodyEnd: registration.end,
-                line: registration.line,
-                anchor: registration.anchor,
-                implementationKey: `${path}#${owner}.${registration.handler.replace(/^@/, '')}`,
-                entryIdentities: [registration.selector],
-            })),
-        });
-    });
-    return result;
-}
-function emitFamilies(families) {
-    const records = [];
-    const familyIds = new Map();
-    const branchEntries = new Map();
-    for (const family of families) {
-        const familyId = recordStableId(family.kind, family.path, family.owner, family.identity);
-        const selectorDomain = family.selectorDomainIdentity ?? family.selectorSubject;
-        const proofStatus = family.proofStatus ?? 'proof-complete';
-        const inventoryMarker = proofStatus === 'proof-complete'
-            ? 'proof-complete:pascal-typed-registry'
-            : 'discovery-lead:pascal-open-membership';
-        familyIds.set(family, familyId);
-        records.push({
-            kind: family.kind,
-            projections: ['registry_families'],
-            presumptiveInventory: proofStatus === 'proof-complete',
-            proofStatus,
-            path: family.path,
-            line: family.line,
-            anchor: family.anchor,
-            owner: family.owner,
-            identity: family.identity,
-            tokens: [family.selectorSubject, selectorDomain, inventoryMarker],
-            semanticIdentityKey: `pascal-registry-family\0${family.path}#${family.owner}\0${family.identity}`,
-            identityComponents: {
-                identity_kind: 'pascal-registry-family',
-                owner_identity: `${family.path}#${family.owner}`,
-                selector_domain: selectorDomain,
-            },
-        });
-        for (const branch of family.branches) {
-            const selectors = branch.entryIdentities.length > 0
-                ? branch.entryIdentities
-                : branch.labelTokens.map(selectorText);
-            const entries = [];
-            selectors.forEach((selector, selectorIndex) => {
-                const implementationKey = branch.implementationKey.startsWith(`${family.path}#`)
-                    ? branch.implementationKey
-                    : `${family.path}#${family.owner}:${branch.implementationKey}`;
-                const identity = `${family.identity}:selector:${selector}:implementation:${implementationKey}:${selectorIndex}`;
-                const entryId = recordStableId(family.entryKind, family.path, family.owner, identity);
-                entries.push(entryId);
-                records.push({
-                    kind: family.entryKind,
-                    projections: ['registry_entries'],
-                    presumptiveInventory: proofStatus === 'proof-complete',
-                    proofStatus,
-                    path: family.path,
-                    line: branch.line,
-                    anchor: branch.anchor,
-                    owner: family.owner,
-                    identity,
-                    tokens: [selector, implementationKey, inventoryMarker],
-                    selectorKey: selector,
-                    implementationKey,
-                    selectorFamilyRecordId: familyId,
-                    semanticIdentityKey: `pascal-registry-entry\0${family.path}#${family.owner}\0${family.identity}\0${selector}\0${implementationKey}`,
-                    identityComponents: {
-                        identity_kind: 'pascal-registry-entry',
-                        owner_identity: `${family.path}#${family.owner}`,
-                        selector_domain: selectorDomain,
-                        selector_key: selector,
-                        implementation_identity: implementationKey,
-                    },
-                });
-            });
-            branchEntries.set(branch, entries);
-        }
-    }
-    for (const child of families.filter((family) => family.kind === 'pascal-typed-case-family')) {
-        const owners = families
-            .filter((family) => family !== child && family.proofStatus !== 'discovery-lead'
-            && child.start > family.start && child.end < family.end)
-            .map((family) => ({
-            family,
-            branch: family.branches.find((candidate) => child.start >= candidate.bodyStart && child.end <= candidate.bodyEnd),
-        }))
-            .filter((owner) => owner.branch !== undefined)
-            .sort((left, right) => (left.family.end - left.family.start) - (right.family.end - right.family.start));
-        const owner = owners[0];
-        if (!owner)
-            continue;
-        const { family: parent, branch } = owner;
-        const childFamilyId = familyIds.get(child);
-        for (const parentEntryId of branchEntries.get(branch) ?? []) {
-            const identity = `edge:${parentEntryId}:${childFamilyId}`;
-            records.push({
-                kind: 'pascal-typed-selector-edge',
-                projections: ['registry_edges'],
-                presumptiveInventory: true,
-                proofStatus: 'proof-complete',
-                path: parent.path,
-                line: child.line,
-                anchor: child.anchor,
-                owner: parent.owner,
-                identity,
-                tokens: [parentEntryId, childFamilyId, 'proof-complete:pascal-typed-registry'],
-                parentSelectorEntryRecordId: parentEntryId,
-                childSelectorFamilyRecordId: childFamilyId,
-                relationKind: 'parent-key-partitions-selector',
-                semanticIdentityKey: `pascal-registry-edge\0${parentEntryId}\0${childFamilyId}\0parent-key-partitions-selector`,
-                identityComponents: {
-                    identity_kind: 'pascal-registry-edge',
-                    owner_identity: `${parent.path}#${parent.owner}`,
-                    selector_domain: child.selectorDomainIdentity ?? child.selectorSubject,
-                    parent_entry_identity: parentEntryId,
-                    child_family_identity: childFamilyId,
-                    relation_kind: 'parent-key-partitions-selector',
-                },
-            });
-        }
-    }
-    return records;
-}
-export function scanPascalSelectorIdentities(repositoryRoot, trackedPaths) {
-    const records = [];
-    const paths = [...new Set(trackedPaths.map(normalizePath))].sort();
-    for (const path of paths) {
-        if (!PASCAL_EXTENSIONS.has(extname(path).toLowerCase()) || isTestRoot(path))
-            continue;
-        const absolute = join(repositoryRoot, path);
-        let source;
-        try {
-            const stat = statSync(absolute);
-            if (!stat.isFile() || stat.size > MAX_PASCAL_SOURCE_BYTES)
-                continue;
-            const bytes = readFileSync(absolute);
-            if (bytes.includes(0))
-                continue;
-            source = bytes.toString('utf8');
-        }
-        catch {
-            continue;
-        }
-        const lines = source.split(/\r?\n/);
-        const tokens = tokenizePascal(source);
-        const routines = routineRanges(tokens);
-        const families = [
-            ...scanCaseFamilies(path, source, lines, tokens, routines),
-            ...scanConditionalFamilies(path, source, lines, tokens, routines),
-            ...scanAddMethodFamilies(path, source, lines, tokens, routines),
-        ].sort((left, right) => left.start - right.start || left.kind.localeCompare(right.kind));
-        records.push(...emitFamilies(families));
-    }
-    return records.sort((left, right) => left.path.localeCompare(right.path)
-        || left.line - right.line
-        || left.kind.localeCompare(right.kind)
-        || left.identity.localeCompare(right.identity));
-}