@jhlagado/azm 0.1.1 → 0.2.1

package/dist/src/register-care/annotations.d.ts

@@ -0,0 +1,8 @@
+import type { RegisterCareAnnotationFile, RegisterCareOutputCandidate, RegisterCareRoutine, RoutineSummary } from './types.js';
+export declare function buildAnnotations(loaded: {
+    sourceTexts: ReadonlyMap<string, string>;
+}, programRoutines: readonly RegisterCareRoutine[], summariesByName: ReadonlyMap<string, RoutineSummary>, outputCandidates: readonly RegisterCareOutputCandidate[], options: {
+    fixOutputCandidates: boolean;
+    outputCandidateFixability: ReadonlyMap<string, boolean>;
+    outputCandidateKey: (file: string, line: number, column: number) => string;
+}): readonly RegisterCareAnnotationFile[];

package/dist/src/register-care/annotations.js

@@ -0,0 +1,41 @@
+import { annotateRegisterCareContracts } from './annotate.js';
+import { applyExpectOutFixesToSource, findExpectOutFixesForCandidates, } from './fix.js';
+export function buildAnnotations(loaded, programRoutines, summariesByName, outputCandidates, options) {
+    const routines = programRoutines
+        .filter((routine) => summariesByName.has(routine.name))
+        .map((routine) => ({
+        routine,
+        summary: summariesByName.get(routine.name),
+    }));
+    const annotated = annotateRegisterCareContracts(loaded.sourceTexts, routines);
+    if (!options.fixOutputCandidates) {
+        return annotated.map((file) => ({ path: file.path, text: file.text }));
+    }
+    const autoFixableCandidates = outputCandidates.filter((candidate) => options.outputCandidateFixability.get(options.outputCandidateKey(candidate.file, candidate.line, candidate.column)) === true);
+    const fixes = findExpectOutFixesForCandidates([...programRoutines], autoFixableCandidates);
+    if (fixes.length === 0) {
+        return annotated.map((file) => ({ path: file.path, text: file.text }));
+    }
+    const workingTexts = new Map(loaded.sourceTexts);
+    for (const file of annotated) {
+        workingTexts.set(file.path, file.text);
+    }
+    const out = [];
+    const fixesByFile = new Map();
+    for (const fix of fixes) {
+        const items = fixesByFile.get(fix.file) ?? [];
+        items.push(fix);
+        fixesByFile.set(fix.file, items);
+    }
+    for (const [path, text] of workingTexts) {
+        const reference = loaded.sourceTexts.get(path);
+        if (reference === undefined)
+            continue;
+        const fileFixes = fixesByFile.get(path) ?? [];
+        const nextText = fileFixes.length > 0 ? applyExpectOutFixesToSource(text, fileFixes, reference) : text;
+        if (nextText !== reference) {
+            out.push({ path, text: nextText });
+        }
+    }
+    return out.sort((left, right) => left.path.localeCompare(right.path));
+}

package/dist/src/register-care/boundaryHints.d.ts

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

package/dist/src/register-care/boundaryHints.js

@@ -0,0 +1,11 @@
+export function precedingCServiceName(item) {
+    const instruction = item?.instruction;
+    if (!instruction || instruction.mnemonic !== 'ld')
+        return undefined;
+    if (instruction.target?.kind !== 'reg8' || instruction.target.register !== 'c')
+        return undefined;
+    if (instruction.source.kind === 'imm' && instruction.source.expression.kind === 'symbol') {
+        return instruction.source.expression.name;
+    }
+    return undefined;
+}

package/dist/src/register-care/carriers.d.ts

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

package/dist/src/register-care/carriers.js

@@ -0,0 +1,78 @@
+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',
+};
+function normalizeCarrierName(raw) {
+    const trimmed = raw.trim();
+    const upper = trimmed.toUpperCase();
+    const flag = FLAG_ALIASES[upper];
+    if (flag !== undefined)
+        return flag;
+    if (SINGLE_UNITS.has(upper))
+        return upper;
+    return undefined;
+}
+function expandCarrier(raw) {
+    const upper = raw.trim().toUpperCase();
+    if (upper === 'F')
+        return FLAG_UNITS;
+    const pair = PAIRS[upper];
+    if (pair !== undefined)
+        return pair;
+    const single = normalizeCarrierName(raw);
+    return single !== undefined ? [single] : undefined;
+}
+export function expandCarrierList(raw) {
+    const out = [];
+    const seen = new Set();
+    for (const item of raw) {
+        const expanded = expandCarrier(item);
+        if (expanded === undefined)
+            return undefined;
+        for (const unit of expanded) {
+            if (seen.has(unit))
+                continue;
+            seen.add(unit);
+            out.push(unit);
+        }
+    }
+    return out;
+}

package/dist/src/register-care/controlFlow.d.ts

@@ -0,0 +1,5 @@
+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/src/register-care/controlFlow.js

@@ -0,0 +1,38 @@
+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];
+    }
+    if (effect.control.kind === 'return') {
+        return effect.control.conditional && next !== undefined ? [next] : [];
+    }
+    return [];
+}

package/dist/src/register-care/fix.d.ts

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

package/dist/src/register-care/fix.js

@@ -0,0 +1,130 @@
+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));
+}
+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;
+}
+export function findExpectOutFixesForCandidates(routines, candidates) {
+    return findExpectOutFixes(routines, candidates);
+}
+export function autoFixableCandidateKeys(routines, candidates) {
+    const fixes = findExpectOutFixes(routines, candidates);
+    const out = new Set();
+    for (const fix of fixes) {
+        out.add(`${fix.file}:${fix.line}:${fix.column}`);
+    }
+    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/src/register-care/instruction-shape.d.ts

@@ -0,0 +1,11 @@
+import type { Z80Instruction, Z80Operand } from '../z80/instruction.js';
+import type { RegisterCareInstruction } from './types.js';
+export declare function instructionHead(item: RegisterCareInstruction): string;
+export declare function regName(operand: Z80Operand | undefined): string | undefined;
+export declare function instructionOperandCount(instruction: Z80Instruction): number;
+export declare function instructionOperand(instruction: Z80Instruction, index: number): Z80Operand | undefined;
+export declare function isUnconditionalReturnInstruction(item: RegisterCareInstruction): boolean;
+export declare function isPureTokenTransferInstruction(item: RegisterCareInstruction): boolean;
+export declare function isAccumulatorSelfOperand(item: RegisterCareInstruction): boolean;
+export declare function isImmediateZeroOperand(item: RegisterCareInstruction): boolean;
+export declare function isRegisterOperand(item: RegisterCareInstruction | undefined, index: number, name: string): boolean;

package/dist/src/register-care/instruction-shape.js

@@ -0,0 +1,129 @@
+export function instructionHead(item) {
+    return item.instruction.mnemonic.toLowerCase();
+}
+export function regName(operand) {
+    if (operand === undefined)
+        return undefined;
+    switch (operand.kind) {
+        case 'reg8':
+            return operand.register.toUpperCase();
+        case 'reg16':
+            return operand.register.toUpperCase();
+        case 'reg-index16':
+            return operand.register.toUpperCase();
+        case 'reg-half-index':
+            return operand.register.toUpperCase();
+        default:
+            return undefined;
+    }
+}
+function immValue(operand) {
+    if (operand?.kind !== 'imm')
+        return undefined;
+    const expression = operand.expression;
+    return expression.kind === 'number' ? expression.value : undefined;
+}
+export function instructionOperandCount(instruction) {
+    switch (instruction.mnemonic) {
+        case 'ret':
+        case 'ret-cc':
+            return instruction.mnemonic === 'ret' ? 0 : 1;
+        case 'ld':
+            return 2;
+        case 'ex':
+            return 2;
+        case 'jp':
+        case 'jp-cc':
+        case 'jr':
+        case 'jr-cc':
+        case 'djnz':
+        case 'call':
+        case 'call-cc':
+            return 1;
+        case 'add':
+        case 'adc':
+        case 'sbc':
+            return 'target' in instruction ? 2 : 1;
+        case 'sub':
+        case 'and':
+        case 'or':
+        case 'xor':
+        case 'cp':
+            return 1;
+        default:
+            return 0;
+    }
+}
+export function instructionOperand(instruction, index) {
+    switch (instruction.mnemonic) {
+        case 'ld':
+            return index === 0 ? instruction.target : index === 1 ? instruction.source : undefined;
+        case 'ex': {
+            if (index === 0) {
+                return instruction.form === 'de-hl'
+                    ? { kind: 'reg16', register: 'de' }
+                    : instruction.form === 'af-af'
+                        ? { kind: 'reg16', register: 'af' }
+                        : undefined;
+            }
+            if (index === 1) {
+                return instruction.form === 'de-hl'
+                    ? { kind: 'reg16', register: 'hl' }
+                    : undefined;
+            }
+            return undefined;
+        }
+        case 'add':
+        case 'adc':
+        case 'sbc':
+            if ('target' in instruction) {
+                return index === 0 ? instruction.target : index === 1 ? instruction.source : undefined;
+            }
+            return index === 0 ? instruction.source : undefined;
+        case 'sub':
+        case 'and':
+        case 'or':
+        case 'xor':
+        case 'cp':
+            return index === 0 ? instruction.source : undefined;
+        default:
+            return undefined;
+    }
+}
+export function isUnconditionalReturnInstruction(item) {
+    const head = instructionHead(item);
+    if (head === 'ret')
+        return item.instruction.mnemonic === 'ret';
+    return head === 'retn' || head === 'reti';
+}
+export function isPureTokenTransferInstruction(item) {
+    const head = instructionHead(item);
+    if (head === 'ex')
+        return true;
+    if (head !== 'ld' || instructionOperandCount(item.instruction) !== 2)
+        return false;
+    const dst = instructionOperand(item.instruction, 0);
+    const src = instructionOperand(item.instruction, 1);
+    if (regName(dst) === undefined)
+        return false;
+    return regName(src) !== undefined || src?.kind === 'imm';
+}
+export function isAccumulatorSelfOperand(item) {
+    const inst = item.instruction;
+    if (inst.mnemonic === 'or' || inst.mnemonic === 'and' || inst.mnemonic === 'xor') {
+        return inst.source.kind === 'reg8' && inst.source.register === 'a';
+    }
+    return false;
+}
+export function isImmediateZeroOperand(item) {
+    const inst = item.instruction;
+    if (inst.mnemonic !== 'cp')
+        return false;
+    return immValue(inst.source) === 0;
+}
+export function isRegisterOperand(item, index, name) {
+    if (item === undefined)
+        return false;
+    const operand = instructionOperand(item.instruction, index);
+    return regName(operand) === name.toUpperCase();
+}

package/dist/src/register-care/liveness.d.ts

@@ -0,0 +1,3 @@
+import type { LocatedSmartComment, RegisterCareConflict, RegisterCareOutputCandidate, RegisterCareRoutine, 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[];

package/dist/src/register-care/liveness.js

@@ -0,0 +1,197 @@
+import { getZ80InstructionEffect } from '../z80/effects.js';
+import { precedingCServiceName } from './boundaryHints.js';
+import { instructionSuccessors, labelIndex } from './controlFlow.js';
+import { rstServiceTargetName, rstTargetName } from './profiles.js';
+function unique(units) {
+    return [...new Set(units)];
+}
+function boundaryTarget(routine, index, effect) {
+    const item = routine.instructions[index];
+    if (effect.control.kind === 'call' && effect.control.target) {
+        return {
+            targets: [effect.control.target],
+            conditional: effect.control.conditional,
+            subject: `CALL ${effect.control.target}`,
+        };
+    }
+    if (effect.control.kind === 'jump' &&
+        item?.instruction.mnemonic === 'jp' &&
+        !effect.control.conditional &&
+        effect.control.target &&
+        !effect.control.target.startsWith('.')) {
+        return {
+            targets: [effect.control.target],
+            conditional: false,
+            subject: `JP ${effect.control.target}`,
+        };
+    }
+    if (effect.control.kind === 'rst' && effect.control.vector !== undefined) {
+        const target = rstTargetName(effect.control.vector);
+        const service = precedingCServiceName(routine.instructions[index - 1]);
+        const targets = service
+            ? [rstServiceTargetName(effect.control.vector, service), target]
+            : [target];
+        return { targets, conditional: false, subject: target };
+    }
+    return undefined;
+}
+function summaryForBoundary(boundary, summaries) {
+    for (const target of boundary.targets) {
+        const summary = summaries.get(target);
+        if (summary)
+            return { target, summary };
+    }
+    return undefined;
+}
+function hintUnitsForLine(hints, file, callLine) {
+    const prior = hints.find((hint) => hint.file === file && hint.line === callLine - 1 && hint.comment.kind === 'expectOut');
+    return prior?.comment.kind === 'expectOut' ? unique(prior.comment.carriers) : [];
+}
+function outputUnits(summary) {
+    return unique(summary.valueRelations.flatMap((relation) => relation.out));
+}
+function setEqual(left, right) {
+    if (left.size !== right.size)
+        return false;
+    for (const item of left)
+        if (!right.has(item))
+            return false;
+    return true;
+}
+function unionLive(sets) {
+    const out = new Set();
+    for (const set of sets) {
+        for (const unit of set)
+            out.add(unit);
+    }
+    return out;
+}
+function transferLiveBefore(item, effect, boundary, summary, liveAfter, hints) {
+    const live = new Set(liveAfter);
+    if (boundary && summary) {
+        const accepted = new Set();
+        for (const unit of hintUnitsForLine(hints, item.file, item.line))
+            accepted.add(unit);
+        for (const unit of outputUnits(summary))
+            accepted.add(unit);
+        if (!boundary.conditional) {
+            for (const unit of summary.mayWrite)
+                live.delete(unit);
+            for (const unit of accepted)
+                live.delete(unit);
+        }
+        for (const unit of summary.mayRead)
+            live.add(unit);
+    }
+    const instructionWritesAreConditional = effect.control.kind === 'call' && effect.control.conditional;
+    if (!instructionWritesAreConditional) {
+        for (const unit of effect.writes)
+            live.delete(unit);
+    }
+    for (const unit of effect.reads)
+        live.add(unit);
+    return live;
+}
+function liveSetsForRoutine(routine, summaries, hints = []) {
+    const labels = labelIndex(routine);
+    const effects = routine.instructions.map((item) => getZ80InstructionEffect(item.instruction));
+    const boundaries = effects.map((effect, index) => boundaryTarget(routine, index, effect));
+    const resolvedSummaries = boundaries.map((boundary) => boundary ? summaryForBoundary(boundary, summaries)?.summary : undefined);
+    const successorIndexes = effects.map((effect, index) => instructionSuccessors(routine, index, effect, labels, { boundaryFallthrough: true }));
+    const liveIn = routine.instructions.map(() => new Set());
+    const liveOut = routine.instructions.map(() => new Set());
+    let changed = true;
+    let passes = 0;
+    while (changed && passes < Math.max(8, routine.instructions.length * 4)) {
+        changed = false;
+        passes += 1;
+        for (let index = routine.instructions.length - 1; index >= 0; index -= 1) {
+            const nextOut = unionLive(successorIndexes[index].map((successor) => liveIn[successor]));
+            const nextIn = transferLiveBefore(routine.instructions[index], effects[index], boundaries[index], resolvedSummaries[index], nextOut, hints);
+            if (!setEqual(nextOut, liveOut[index])) {
+                liveOut[index] = nextOut;
+                changed = true;
+            }
+            if (!setEqual(nextIn, liveIn[index])) {
+                liveIn[index] = nextIn;
+                changed = true;
+            }
+        }
+    }
+    return { liveIn, liveOut };
+}
+function resolvedBoundariesForRoutine(routine, summaries) {
+    const out = [];
+    for (let index = 0; index < routine.instructions.length; index += 1) {
+        const item = routine.instructions[index];
+        const effect = getZ80InstructionEffect(item.instruction);
+        const boundary = boundaryTarget(routine, index, effect);
+        if (!boundary)
+            continue;
+        const resolved = summaryForBoundary(boundary, summaries);
+        if (!resolved)
+            continue;
+        out.push({ item, index, boundary, target: resolved.target, summary: resolved.summary });
+    }
+    return out;
+}
+export function findRegisterCareConflicts(routine, summaries, hints) {
+    const conflicts = [];
+    const { liveOut } = liveSetsForRoutine(routine, summaries, hints);
+    for (const { item, index, boundary, target, summary } of resolvedBoundariesForRoutine(routine, summaries)) {
+        const accepted = new Set();
+        for (const unit of hintUnitsForLine(hints, item.file, item.line))
+            accepted.add(unit);
+        for (const unit of outputUnits(summary))
+            accepted.add(unit);
+        const carriers = unique(summary.mayWrite.filter((unit) => liveOut[index].has(unit) && !accepted.has(unit)));
+        if (carriers.length > 0) {
+            conflicts.push({
+                file: item.file,
+                line: item.line,
+                column: item.column,
+                callTarget: target,
+                carriers,
+                message: `${boundary.subject} may modify ${carriers.join(',')}, but the pre-call value is used later.`,
+            });
+        }
+    }
+    return conflicts;
+}
+function candidateMessage(boundary, units) {
+    const carriers = units.join(',');
+    const expectation = units.length === 1 ? units[0] : `{${carriers}}`;
+    return `${boundary.subject} writes ${carriers} and caller reads it later; review the call site and add \`; expects out ${expectation}\` above the call if this is intentional.`;
+}
+export function findCallerOutputCandidateObservations(routines, summaries) {
+    const out = [];
+    for (const routine of routines) {
+        const { liveOut } = liveSetsForRoutine(routine, summaries);
+        for (const { item, index, boundary, target, summary } of resolvedBoundariesForRoutine(routine, summaries)) {
+            const intentionalOutputs = new Set(outputUnits(summary));
+            const carrierSources = [];
+            for (const unit of summary.mayWrite) {
+                if (liveOut[index].has(unit) && !intentionalOutputs.has(unit)) {
+                    carrierSources.push(unit);
+                }
+            }
+            for (const unit of intentionalOutputs) {
+                if (liveOut[index].has(unit)) {
+                    carrierSources.push(unit);
+                }
+            }
+            const carriers = unique(carrierSources);
+            if (carriers.length > 0) {
+                out.push({
+                    file: item.file,
+                    line: item.line,
+                    column: item.column,
+                    routine: target,
+                    carriers,
+                    message: candidateMessage(boundary, carriers),
+                });
+            }
+        }
+    }
+    return out;
+}