@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/registerCare/analyze.js

@@ -1,327 +0,0 @@
-import { DiagnosticIds } from '../diagnosticTypes.js';
-import { annotateRegisterCareContracts } from './annotate.js';
-import { expandCarrierList } from './carriers.js';
-import { diagnosticsForRegisterCareConflicts, findAcceptedOutputCandidatesFromHints, findCallerOutputCandidates, findCallerOutputCandidateObservations, findRegisterCareConflicts, } from './liveness.js';
-import { applyExpectOutFixesToSource, findExpectOutFixes } from './fix.js';
-import { getRegisterCareProfile } from './profiles.js';
-import { buildRegisterCareProgramModel } from './programModel.js';
-import { renderRegisterCareInterface, renderRegisterCareReport } from './report.js';
-import { buildRoutineContracts, parseSmartComments } from './smartComments.js';
-import { applyRoutineContract, inferRoutineSummary } from './summary.js';
-function emptyRoutineSummary(name) {
-    return {
-        name,
-        mayRead: [],
-        mayWrite: [],
-        preserved: [],
-        valueRelations: [],
-        stackBalanced: true,
-        hasUnknownStackEffect: false,
-    };
-}
-function unknownBoundaryForCall(call) {
-    return {
-        ...call,
-        message: `Register-care cannot prove ${call.subject}; add a routine body or .asmi extern contract.`,
-    };
-}
-function uniqueSortedTargets(boundaries) {
-    return Array.from(new Set(boundaries.map((boundary) => boundary.target))).sort();
-}
-function diagnosticsForUnknownBoundaries(boundaries) {
-    return boundaries.map((boundary) => ({
-        id: DiagnosticIds.RegisterCareUnknownBoundary,
-        severity: 'warning',
-        message: boundary.message,
-        file: boundary.file,
-        line: boundary.line,
-        column: boundary.column,
-    }));
-}
-function isLocalLabel(name) {
-    return name.startsWith('.');
-}
-function nonLocalLabels(labels) {
-    return labels.filter((label) => !isLocalLabel(label));
-}
-function boundaryLabels(routine) {
-    return routine.entryLabels ?? nonLocalLabels(routine.labels);
-}
-function contractForRoutine(routine, contracts) {
-    return boundaryLabels(routine)
-        .map((label) => contracts.get(label))
-        .find((contract) => contract !== undefined);
-}
-function summariesWithExternalContracts(summaries, contracts, routineNames) {
-    const out = [...summaries];
-    for (const contract of contracts.values()) {
-        if (!routineNames.has(contract.name)) {
-            out.push(applyRoutineContract(emptyRoutineSummary(contract.name), contract));
-        }
-    }
-    return out;
-}
-function externalContractsOnly(contracts, routineNames) {
-    return new Map([...contracts].filter(([name]) => !routineNames.has(name)));
-}
-function buildBoundarySummaryMap(summaries, routineSummaries, profileSummaries) {
-    const boundarySummaryMap = new Map(profileSummaries.map((summary) => [summary.name, summary]));
-    for (const summary of summaries) {
-        boundarySummaryMap.set(summary.name, summary);
-    }
-    for (const { routine, summary } of routineSummaries) {
-        for (const label of boundaryLabels(routine)) {
-            boundarySummaryMap.set(label, summary);
-        }
-    }
-    return boundarySummaryMap;
-}
-function summarizeRoutines(routines, contracts, boundarySummaryMap = new Map()) {
-    return routines.map((routine) => {
-        const inferred = inferRoutineSummary(routine, boundarySummaryMap);
-        const contract = contractForRoutine(routine, contracts);
-        return { routine, summary: contract ? applyRoutineContract(inferred, contract) : inferred };
-    });
-}
-function sortedUnique(values) {
-    return Array.from(new Set(values)).sort();
-}
-function appendUniqueUnits(target, units) {
-    for (const unit of units) {
-        if (!target.includes(unit))
-            target.push(unit);
-    }
-}
-function summaryFingerprint(summary) {
-    const relations = summary.valueRelations
-        .map((relation) => `${relation.out.join(',')}<-${relation.from.join(',')}`)
-        .sort();
-    return JSON.stringify({
-        name: summary.name,
-        mayRead: sortedUnique(summary.mayRead),
-        mayWrite: sortedUnique(summary.mayWrite),
-        preserved: sortedUnique(summary.preserved),
-        relations,
-        stackBalanced: summary.stackBalanced,
-        hasUnknownStackEffect: summary.hasUnknownStackEffect,
-    });
-}
-function routineSummariesFingerprint(routineSummaries) {
-    return routineSummaries.map((item) => summaryFingerprint(item.summary)).join('\n');
-}
-function inferRoutineSummariesToFixedPoint(routines, contracts, routineNames, profileSummaries) {
-    let routineSummaries = summarizeRoutines(routines, contracts);
-    const maxPasses = Math.max(2, routines.length + 2);
-    for (let pass = 0; pass < maxPasses; pass += 1) {
-        const summaries = summariesWithExternalContracts(routineSummaries.map((item) => item.summary), contracts, routineNames);
-        const boundarySummaryMap = buildBoundarySummaryMap(summaries, routineSummaries, profileSummaries);
-        const nextRoutineSummaries = summarizeRoutines(routines, contracts, boundarySummaryMap);
-        if (routineSummariesFingerprint(nextRoutineSummaries) ===
-            routineSummariesFingerprint(routineSummaries)) {
-            return nextRoutineSummaries;
-        }
-        routineSummaries = nextRoutineSummaries;
-    }
-    return routineSummaries;
-}
-function withCallerOutputCandidates(routineSummaries, boundarySummaryMap, acceptOutputCandidates = new Map()) {
-    const candidates = findCallerOutputCandidates(routineSummaries.map((item) => item.routine), new Map(boundarySummaryMap));
-    return routineSummaries.map((item) => {
-        const outputCandidates = candidates.get(item.summary.name);
-        const written = new Set(item.summary.mayWrite);
-        const accepted = (acceptOutputCandidates.get(item.summary.name) ?? []).filter((unit) => written.has(unit));
-        const acceptedSet = new Set(accepted);
-        const valueRelations = [...item.summary.valueRelations];
-        for (const unit of accepted) {
-            if (!valueRelations.some((relation) => relation.out.includes(unit))) {
-                valueRelations.push({ out: [unit], from: [] });
-            }
-        }
-        const remainingCandidates = outputCandidates?.filter((unit) => !acceptedSet.has(unit));
-        return outputCandidates && outputCandidates.length > 0
-            ? {
-                ...item,
-                summary: {
-                    ...item.summary,
-                    valueRelations,
-                    ...(remainingCandidates && remainingCandidates.length > 0
-                        ? { outputCandidates: remainingCandidates }
-                        : {}),
-                },
-            }
-            : item;
-    });
-}
-function autoAcceptedOutputCandidates(fixes) {
-    const out = new Map();
-    for (const fix of fixes) {
-        const existing = out.get(fix.routine) ?? [];
-        appendUniqueUnits(existing, fix.carriers);
-        out.set(fix.routine, existing);
-    }
-    return out;
-}
-function parseAcceptedOutputCandidates(items = []) {
-    const out = new Map();
-    for (const item of items) {
-        const sep = item.indexOf(':');
-        if (sep <= 0 || sep === item.length - 1) {
-            throw new Error(`Invalid --accept-out value "${item}" (expected ROUTINE:carriers)`);
-        }
-        const name = item.slice(0, sep).trim();
-        if (!name)
-            throw new Error(`Invalid --accept-out value "${item}" (missing routine name)`);
-        const carrierParts = item.slice(sep + 1).split(',');
-        const rawCarriers = carrierParts.map((part) => part.trim());
-        if (rawCarriers.length === 0 || rawCarriers.some((part) => part.length === 0)) {
-            throw new Error(`Invalid --accept-out value "${item}" (missing carriers)`);
-        }
-        const carriers = expandCarrierList(rawCarriers);
-        if (!carriers) {
-            throw new Error(`Invalid --accept-out value "${item}" (unknown carrier)`);
-        }
-        const existing = out.get(name) ?? [];
-        appendUniqueUnits(existing, carriers);
-        out.set(name, existing);
-    }
-    return out;
-}
-function mergeAcceptedOutputCandidates(...maps) {
-    const out = new Map();
-    for (const map of maps) {
-        for (const [name, units] of map) {
-            const existing = out.get(name) ?? [];
-            appendUniqueUnits(existing, units);
-            out.set(name, existing);
-        }
-    }
-    return out;
-}
-function fixedSourceTexts(referenceSourceTexts, workingSourceTexts, fixes) {
-    const byFile = new Map();
-    for (const fix of fixes) {
-        const items = byFile.get(fix.file) ?? [];
-        items.push(fix);
-        byFile.set(fix.file, items);
-    }
-    const out = new Map(workingSourceTexts);
-    for (const [file, items] of byFile) {
-        const source = workingSourceTexts.get(file);
-        const referenceSource = referenceSourceTexts.get(file);
-        if (source === undefined)
-            continue;
-        out.set(file, applyExpectOutFixesToSource(source, items, referenceSource));
-    }
-    return out;
-}
-function annotateAndFixRegisterCareContracts(sourceTexts, routines, fixes) {
-    const annotated = annotateRegisterCareContracts(sourceTexts, routines);
-    if (fixes.length === 0)
-        return annotated;
-    const workingTexts = new Map(sourceTexts);
-    for (const file of annotated) {
-        workingTexts.set(file.path, file.text);
-    }
-    const fixedTexts = fixedSourceTexts(sourceTexts, workingTexts, fixes);
-    const out = [];
-    for (const [path, text] of fixedTexts) {
-        if (text !== sourceTexts.get(path))
-            out.push({ path, text });
-    }
-    return out.sort((a, b) => a.path.localeCompare(b.path));
-}
-function candidateKey(item) {
-    return `${item.file}:${item.line}:${item.column}:${item.routine}`;
-}
-function candidateExpectation(units) {
-    const carriers = units.join(',');
-    return units.length === 1 ? units[0] : `{${carriers}}`;
-}
-function candidateMessageWithFixability(candidate, autoFixable) {
-    const carriers = candidate.carriers.join(',');
-    const expectation = candidateExpectation(candidate.carriers);
-    const base = `CALL ${candidate.routine} writes ${carriers} and caller reads it later`;
-    return autoFixable
-        ? `${base}; generated contracts promote this to \`out ${expectation}\` automatically.`
-        : `${base}; manual review required before adding \`; expects out ${expectation}\` because the later read is not a simple direct continuation.`;
-}
-function withCandidateFixability(candidates, fixes) {
-    const fixable = new Map(fixes.map((fix) => [candidateKey(fix), new Set(fix.carriers)]));
-    return candidates.map((candidate) => {
-        const fixableCarriers = fixable.get(candidateKey(candidate));
-        const autoFixable = fixableCarriers !== undefined &&
-            candidate.carriers.every((carrier) => fixableCarriers.has(carrier));
-        return {
-            ...candidate,
-            autoFixable,
-            message: candidateMessageWithFixability(candidate, autoFixable),
-        };
-    });
-}
-function inferenceOnlyOutputFixes(programRoutines, routineSummaries, profileSummaries) {
-    const summaries = routineSummaries.map((item) => item.summary);
-    const boundarySummaryMap = buildBoundarySummaryMap(summaries, routineSummaries, profileSummaries);
-    const candidates = findCallerOutputCandidateObservations(programRoutines, boundarySummaryMap);
-    return findExpectOutFixes(programRoutines, candidates);
-}
-export function analyzeRegisterCare(loaded, options) {
-    const profile = getRegisterCareProfile(options.profile);
-    const programModel = buildRegisterCareProgramModel(loaded.program);
-    const smartComments = parseSmartComments(loaded.sourceLineComments);
-    const contracts = buildRoutineContracts(smartComments, programModel.routines, loaded.sourceTexts);
-    const cliAcceptedOutputCandidates = parseAcceptedOutputCandidates(options.acceptOutputCandidates);
-    for (const contract of options.interfaceContracts ?? []) {
-        contracts.set(contract.name, contract);
-    }
-    const routineNames = new Set(programModel.routines.flatMap((routine) => boundaryLabels(routine)));
-    const profileSummaries = profile
-        ? [...Array.from(profile.rst.values()), ...Array.from(profile.rstServices.values())]
-        : [];
-    const routineSummaries = inferRoutineSummariesToFixedPoint(programModel.routines, contracts, routineNames, profileSummaries);
-    const summaries = routineSummaries.map((item) => item.summary);
-    summaries.push(...summariesWithExternalContracts([], contracts, routineNames));
-    const boundarySummaryMap = buildBoundarySummaryMap(summaries, routineSummaries, profileSummaries);
-    const unknownBoundaries = programModel.directBoundaries
-        .filter((boundary) => !boundarySummaryMap.has(boundary.target))
-        .map(unknownBoundaryForCall);
-    const conflicts = programModel.routines.flatMap((routine) => findRegisterCareConflicts(routine, boundarySummaryMap, smartComments));
-    const rawOutputCandidates = findCallerOutputCandidateObservations(programModel.routines, boundarySummaryMap);
-    const possibleExpectOutFixes = findExpectOutFixes(programModel.routines, rawOutputCandidates);
-    const outputCandidates = withCandidateFixability(rawOutputCandidates, possibleExpectOutFixes);
-    const conflictDiagnostics = options.mode === 'warn' || options.mode === 'strict'
-        ? diagnosticsForRegisterCareConflicts(conflicts, 'warning')
-        : options.mode === 'error'
-            ? diagnosticsForRegisterCareConflicts(conflicts, 'error')
-            : [];
-    const diagnostics = options.mode === 'strict'
-        ? [...conflictDiagnostics, ...diagnosticsForUnknownBoundaries(unknownBoundaries)]
-        : conflictDiagnostics;
-    const reportModel = {
-        entryFile: loaded.program.entryFile,
-        mode: options.mode,
-        ...(profile ? { profile: profile.name } : {}),
-        summaries,
-        conflicts,
-        outputCandidates,
-        unknownCalls: uniqueSortedTargets(unknownBoundaries),
-    };
-    return {
-        diagnostics,
-        outputCandidates,
-        ...(options.emitReport ? { reportText: renderRegisterCareReport(reportModel) } : {}),
-        ...(options.emitInterface ? { interfaceText: renderRegisterCareInterface(summaries) } : {}),
-        ...(options.emitAnnotations
-            ? (() => {
-                const annotationRoutineSummaries = inferRoutineSummariesToFixedPoint(programModel.routines, externalContractsOnly(contracts, routineNames), routineNames, profileSummaries);
-                const annotationSummaries = annotationRoutineSummaries.map((item) => item.summary);
-                const annotationBoundarySummaryMap = buildBoundarySummaryMap(annotationSummaries, annotationRoutineSummaries, profileSummaries);
-                const expectOutFixes = options.fixRegisterContracts === true
-                    ? inferenceOnlyOutputFixes(programModel.routines, annotationRoutineSummaries, profileSummaries)
-                    : [];
-                return {
-                    annotatedFiles: annotateAndFixRegisterCareContracts(loaded.sourceTexts, withCallerOutputCandidates(annotationRoutineSummaries, annotationBoundarySummaryMap, mergeAcceptedOutputCandidates(cliAcceptedOutputCandidates, findAcceptedOutputCandidatesFromHints(programModel.routines, annotationBoundarySummaryMap, smartComments), autoAcceptedOutputCandidates(expectOutFixes))), []),
-                };
-            })()
-            : {}),
-    };
-}

package/dist/legacy-root-azm/src/registerCare/boundaryHints.d.ts

@@ -1,2 +0,0 @@
-import type { RegisterCareInstruction } from './types.js';
-export declare function precedingCServiceName(item: RegisterCareInstruction | undefined): string | undefined;

package/dist/legacy-root-azm/src/registerCare/boundaryHints.js

@@ -1,10 +0,0 @@
-export function precedingCServiceName(item) {
-    const inst = item?.instruction;
-    if (!inst || inst.head.toLowerCase() !== 'ld' || inst.operands.length !== 2)
-        return undefined;
-    const dst = inst.operands[0];
-    const src = inst.operands[1];
-    if (dst?.kind !== 'Reg' || dst.name.toUpperCase() !== 'C')
-        return undefined;
-    return src?.kind === 'Imm' && src.expr.kind === 'ImmName' ? src.expr.name : undefined;
-}

package/dist/legacy-root-azm/src/registerCare/carriers.d.ts

@@ -1,4 +0,0 @@
-import type { RegisterCareUnit } from './types.js';
-export declare function normalizeCarrierName(raw: string): RegisterCareUnit | undefined;
-export declare function expandCarrier(raw: string): RegisterCareUnit[] | undefined;
-export declare function expandCarrierList(raw: string[]): RegisterCareUnit[] | undefined;

package/dist/legacy-root-azm/src/registerCare/carriers.js

@@ -1,78 +0,0 @@
-const FLAG_UNITS = ['carry', 'zero', 'sign', 'parity', 'halfCarry'];
-const SINGLE_UNITS = new Set([
-    'A',
-    'B',
-    'C',
-    'D',
-    'E',
-    'H',
-    'L',
-    'IXH',
-    'IXL',
-    'IYH',
-    'IYL',
-    'SPH',
-    'SPL',
-    'carry',
-    'zero',
-    'sign',
-    'parity',
-    'halfCarry',
-]);
-const PAIRS = {
-    AF: ['A', ...FLAG_UNITS],
-    BC: ['B', 'C'],
-    DE: ['D', 'E'],
-    HL: ['H', 'L'],
-    IX: ['IXH', 'IXL'],
-    IY: ['IYH', 'IYL'],
-    SP: ['SPH', 'SPL'],
-};
-const FLAG_ALIASES = {
-    CARRY: 'carry',
-    ZERO: 'zero',
-    Z: 'zero',
-    SIGN: 'sign',
-    S: 'sign',
-    PARITY: 'parity',
-    PV: 'parity',
-    'P/V': 'parity',
-    HALFCARRY: 'halfCarry',
-    HFLAG: 'halfCarry',
-};
-export function normalizeCarrierName(raw) {
-    const trimmed = raw.trim();
-    const upper = trimmed.toUpperCase();
-    const flag = FLAG_ALIASES[upper];
-    if (flag)
-        return flag;
-    if (SINGLE_UNITS.has(upper))
-        return upper;
-    return undefined;
-}
-export function expandCarrier(raw) {
-    const upper = raw.trim().toUpperCase();
-    if (upper === 'F')
-        return FLAG_UNITS;
-    const pair = PAIRS[upper];
-    if (pair)
-        return pair;
-    const single = normalizeCarrierName(raw);
-    return single ? [single] : undefined;
-}
-export function expandCarrierList(raw) {
-    const out = [];
-    const seen = new Set();
-    for (const item of raw) {
-        const expanded = expandCarrier(item);
-        if (!expanded)
-            return undefined;
-        for (const unit of expanded) {
-            if (seen.has(unit))
-                continue;
-            seen.add(unit);
-            out.push(unit);
-        }
-    }
-    return out;
-}

package/dist/legacy-root-azm/src/registerCare/controlFlow.d.ts

@@ -1,5 +0,0 @@
-import type { InstructionEffect, RegisterCareRoutine } from './types.js';
-export declare function labelIndex(routine: RegisterCareRoutine): Map<string, number>;
-export declare function instructionSuccessors(routine: RegisterCareRoutine, index: number, effect: InstructionEffect, labels: ReadonlyMap<string, number>, options?: {
-    boundaryFallthrough?: boolean;
-}): number[];

package/dist/legacy-root-azm/src/registerCare/controlFlow.js

@@ -1,35 +0,0 @@
-function unique(items) {
-    return [...new Set(items)];
-}
-export function labelIndex(routine) {
-    const out = new Map();
-    routine.instructions.forEach((item, index) => {
-        for (const label of item.labels)
-            out.set(label, index);
-    });
-    return out;
-}
-function localTargetIndex(labels, target) {
-    if (!target)
-        return undefined;
-    return labels.get(target);
-}
-export function instructionSuccessors(routine, index, effect, labels, options = {}) {
-    const next = index + 1 < routine.instructions.length ? index + 1 : undefined;
-    if (effect.control.kind === 'fallthrough' ||
-        (options.boundaryFallthrough &&
-            (effect.control.kind === 'call' || effect.control.kind === 'rst'))) {
-        return next === undefined ? [] : [next];
-    }
-    if (effect.control.kind === 'jump') {
-        const target = localTargetIndex(labels, effect.control.target);
-        if (effect.control.conditional) {
-            return unique([
-                ...(target === undefined ? [] : [target]),
-                ...(next === undefined ? [] : [next]),
-            ]);
-        }
-        return target === undefined ? [] : [target];
-    }
-    return [];
-}

package/dist/legacy-root-azm/src/registerCare/fix.d.ts

@@ -1,11 +0,0 @@
-import type { RegisterCareOutputCandidate, RegisterCareRoutine, RegisterCareUnit } from './types.js';
-interface RegisterCareExpectOutFix {
-    file: string;
-    line: number;
-    column: number;
-    routine: string;
-    carriers: RegisterCareUnit[];
-}
-export declare function findExpectOutFixes(routines: RegisterCareRoutine[], candidates: RegisterCareOutputCandidate[]): RegisterCareExpectOutFix[];
-export declare function applyExpectOutFixesToSource(source: string, fixes: RegisterCareExpectOutFix[], referenceSource?: string): string;
-export {};

package/dist/legacy-root-azm/src/registerCare/fix.js

@@ -1,119 +0,0 @@
-import { getZ80InstructionEffect } from '../z80/effects.js';
-import { instructionSuccessors, labelIndex } from './controlFlow.js';
-import { contractCarrierList } from './report.js';
-import { joinSourceLines, splitSourceLines } from './sourceText.js';
-function sameLocation(a, b) {
-    return a.file === b.file && a.line === b.line && a.column === b.column;
-}
-function isUnconditionalDirectCall(item) {
-    const effect = getZ80InstructionEffect(item.instruction);
-    return (effect.control.kind === 'call' &&
-        effect.control.target !== undefined &&
-        !effect.control.conditional);
-}
-function continuationReads(routine, callIndex, carriers) {
-    const labels = labelIndex(routine);
-    const confirmed = new Set();
-    const work = callIndex + 1 < routine.instructions.length
-        ? [{ index: callIndex + 1, pending: [...new Set(carriers)] }]
-        : [];
-    const seen = new Set();
-    let steps = 0;
-    while (work.length > 0 && steps < 512) {
-        steps += 1;
-        const state = work.pop();
-        const pending = state.pending.filter((unit) => !confirmed.has(unit));
-        if (pending.length === 0)
-            continue;
-        const key = `${state.index}:${pending.join(',')}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        const item = routine.instructions[state.index];
-        if (!item)
-            continue;
-        const effect = getZ80InstructionEffect(item.instruction);
-        const reads = new Set(effect.reads);
-        const writes = new Set(effect.writes);
-        const remaining = [];
-        for (const unit of pending) {
-            if (reads.has(unit)) {
-                confirmed.add(unit);
-                continue;
-            }
-            if (!writes.has(unit))
-                remaining.push(unit);
-        }
-        if (remaining.length === 0)
-            continue;
-        for (const next of instructionSuccessors(routine, state.index, effect, labels)) {
-            work.push({ index: next, pending: remaining });
-        }
-    }
-    return carriers.filter((unit) => confirmed.has(unit));
-}
-export function findExpectOutFixes(routines, candidates) {
-    const out = [];
-    for (const routine of routines) {
-        for (let index = 0; index < routine.instructions.length; index += 1) {
-            const item = routine.instructions[index];
-            if (!isUnconditionalDirectCall(item))
-                continue;
-            const candidate = candidates.find((entry) => sameLocation(item, entry));
-            if (!candidate)
-                continue;
-            const carriers = continuationReads(routine, index, candidate.carriers);
-            if (carriers.length === 0)
-                continue;
-            out.push({ ...candidate, carriers });
-        }
-    }
-    return out;
-}
-function isExpectOutLine(line) {
-    return /^\s*;\s*expects\s+out\b/i.test(line);
-}
-function expectedCallLine(originalLines, fix) {
-    return originalLines[fix.line - 1]?.trim();
-}
-function findCallLineIndex(lines, originalLines, fix) {
-    const expected = expectedCallLine(originalLines, fix);
-    if (!expected)
-        return undefined;
-    const preferred = fix.line - 1;
-    if (lines[preferred]?.trim() === expected)
-        return preferred;
-    let best;
-    let bestDistance = Number.POSITIVE_INFINITY;
-    for (let index = 0; index < lines.length; index += 1) {
-        if (lines[index]?.trim() !== expected)
-            continue;
-        const distance = Math.abs(index - preferred);
-        if (distance < bestDistance) {
-            best = index;
-            bestDistance = distance;
-        }
-    }
-    return best;
-}
-function indentation(line) {
-    return line.match(/^\s*/)?.[0] ?? '';
-}
-export function applyExpectOutFixesToSource(source, fixes, referenceSource = source) {
-    if (fixes.length === 0)
-        return source;
-    const originalLines = referenceSource.split(/\r?\n/);
-    const sourceLines = splitSourceLines(source);
-    const { lines } = sourceLines;
-    const sorted = [...fixes].sort((a, b) => b.line - a.line || b.column - a.column);
-    for (const fix of sorted) {
-        const index = findCallLineIndex(lines, originalLines, fix);
-        if (index === undefined)
-            continue;
-        if (index > 0 && isExpectOutLine(lines[index - 1] ?? ''))
-            continue;
-        const prefix = indentation(lines[index] ?? '');
-        lines.splice(index, 0, `${prefix}; expects out ${contractCarrierList(fix.carriers)}`);
-    }
-    return joinSourceLines(sourceLines);
-}

package/dist/legacy-root-azm/src/registerCare/liveness.d.ts

@@ -1,7 +0,0 @@
-import { type Diagnostic } from '../diagnosticTypes.js';
-import type { LocatedSmartComment, RegisterCareConflict, RegisterCareOutputCandidate, RegisterCareRoutine, RegisterCareUnit, RoutineSummary } from './types.js';
-export declare function findRegisterCareConflicts(routine: RegisterCareRoutine, summaries: Map<string, RoutineSummary>, hints: LocatedSmartComment[]): RegisterCareConflict[];
-export declare function findCallerOutputCandidateObservations(routines: RegisterCareRoutine[], summaries: Map<string, RoutineSummary>): RegisterCareOutputCandidate[];
-export declare function findCallerOutputCandidates(routines: RegisterCareRoutine[], summaries: Map<string, RoutineSummary>): Map<string, RegisterCareUnit[]>;
-export declare function findAcceptedOutputCandidatesFromHints(routines: RegisterCareRoutine[], summaries: Map<string, RoutineSummary>, hints: LocatedSmartComment[]): Map<string, RegisterCareUnit[]>;
-export declare function diagnosticsForRegisterCareConflicts(conflicts: RegisterCareConflict[], severity: 'warning' | 'error'): Diagnostic[];