@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/{register-care → register-contracts}/liveness.js

@@ -7,36 +7,53 @@ function unique(units) {
 }
 function boundaryTarget(routine, index, effect) {
     const item = routine.instructions[index];
-    if (effect.control.kind === 'call' && effect.control.target) {
-        return {
+    return (callBoundaryTarget(effect) ??
+        tailJumpBoundaryTarget(item, effect) ??
+        rstBoundaryTarget(routine, index, effect));
+}
+function callBoundaryTarget(effect) {
+    return effect.control.kind === 'call' && effect.control.target
+        ? {
             targets: [effect.control.target],
             conditional: effect.control.conditional,
             subject: `CALL ${effect.control.target}`,
-        };
-    }
-    if (effect.control.kind === 'jump' &&
+        }
+        : undefined;
+}
+function tailJumpBoundaryTarget(item, effect) {
+    if (!isTailJumpBoundary(item, effect))
+        return undefined;
+    return {
+        targets: [effect.control.target],
+        conditional: false,
+        subject: `JP ${effect.control.target}`,
+    };
+}
+function isTailJumpBoundary(item, effect) {
+    return (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 previous = routine.instructions[index - 1];
-        const service = precedingCServiceName(routine.instructions[index - 1]);
-        const targets = [
-            ...rstDispatcherServiceTargetNames(effect.control.vector, (register) => precedingRegisterImmediateValue(previous, register)),
-            ...(service ? [rstServiceTargetName(effect.control.vector, service)] : []),
-            target,
-        ];
-        return { targets, conditional: false, subject: target };
-    }
-    return undefined;
+        effect.control.target !== undefined &&
+        !effect.control.target.startsWith('.'));
+}
+function rstBoundaryTarget(routine, index, effect) {
+    if (effect.control.kind !== 'rst' || effect.control.vector === undefined)
+        return undefined;
+    const target = rstTargetName(effect.control.vector);
+    return {
+        targets: rstBoundaryTargets(routine, index, effect.control.vector, target),
+        conditional: false,
+        subject: target,
+    };
+}
+function rstBoundaryTargets(routine, index, vector, fallbackTarget) {
+    const previous = routine.instructions[index - 1];
+    const service = precedingCServiceName(previous);
+    return [
+        ...rstDispatcherServiceTargetNames(vector, (register) => precedingRegisterImmediateValue(previous, register)),
+        ...(service ? [rstServiceTargetName(vector, service)] : []),
+        fallbackTarget,
+    ];
 }
 function summaryForBoundary(boundary, summaries) {
     for (const target of boundary.targets) {
@@ -70,50 +87,59 @@ function unionLive(sets) {
     return out;
 }
 function transferLiveBefore(item, effect, boundary, summary, liveAfter, hints) {
+    const live = liveBeforeBoundary(item, boundary, summary, liveAfter, hints);
+    removeInstructionWrites(live, effect);
+    addInstructionReads(live, item, effect, liveAfter);
+    return live;
+}
+function liveBeforeBoundary(item, 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);
+        applyBoundarySummary(live, item, boundary, summary, hints);
     }
-    const instructionWritesAreConditional = effect.control.kind === 'call' && effect.control.conditional;
-    if (!instructionWritesAreConditional) {
+    return live;
+}
+function applyBoundarySummary(live, item, boundary, summary, hints) {
+    const accepted = acceptedOutputUnits(item, summary, hints);
+    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);
+}
+function acceptedOutputUnits(item, summary, hints) {
+    return new Set([...hintUnitsForLine(hints, item.file, item.line), ...outputUnits(summary)]);
+}
+function removeInstructionWrites(live, effect) {
+    if (!instructionWritesAreConditional(effect)) {
         for (const unit of effect.writes)
             live.delete(unit);
     }
+}
+function instructionWritesAreConditional(effect) {
+    return effect.control.kind === 'call' && effect.control.conditional;
+}
+function addInstructionReads(live, item, effect, liveAfter) {
     for (const unit of semanticReadsForLiveness(item, effect, liveAfter))
         live.add(unit);
-    return live;
 }
 function semanticReadsForLiveness(item, effect, liveAfter) {
-    if (item.instruction.mnemonic === 'or' &&
-        item.instruction.source.kind === 'reg8' &&
-        item.instruction.source.register === 'a' &&
-        !liveAfter.has('zero') &&
-        !liveAfter.has('sign') &&
-        !liveAfter.has('parity')) {
-        return effect.reads.filter((unit) => unit !== 'A');
-    }
-    if (item.instruction.mnemonic === 'and' &&
-        item.instruction.source.kind === 'reg8' &&
-        item.instruction.source.register === 'a' &&
-        !liveAfter.has('zero') &&
-        !liveAfter.has('sign') &&
-        !liveAfter.has('parity')) {
+    if (isAccumulatorFlagRefresh(item) && !hasAccumulatorDerivedFlags(liveAfter)) {
         return effect.reads.filter((unit) => unit !== 'A');
     }
     return effect.reads;
 }
+function isAccumulatorFlagRefresh(item) {
+    return ((item.instruction.mnemonic === 'or' || item.instruction.mnemonic === 'and') &&
+        item.instruction.source.kind === 'reg8' &&
+        item.instruction.source.register === 'a');
+}
+function hasAccumulatorDerivedFlags(liveAfter) {
+    return liveAfter.has('zero') || liveAfter.has('sign') || liveAfter.has('parity');
+}
 function liveSetsForRoutine(routine, summaries, hints = []) {
     const labels = labelIndex(routine);
     const effects = routine.instructions.map((item) => getZ80InstructionEffect(item.instruction));
@@ -157,7 +183,7 @@ function resolvedBoundariesForRoutine(routine, summaries) {
     }
     return out;
 }
-export function findRegisterCareConflicts(routine, summaries, hints) {
+export function findRegisterContractsConflicts(routine, summaries, hints) {
     const conflicts = [];
     const { liveOut } = liveSetsForRoutine(routine, summaries, hints);
     for (const { item, index, boundary, target, summary } of resolvedBoundariesForRoutine(routine, summaries)) {
@@ -190,30 +216,36 @@ export function findCallerOutputCandidateObservations(routines, summaries) {
     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),
-                });
-            }
+            const candidate = callerOutputCandidate(item, boundary, target, summary, liveOut[index]);
+            if (candidate)
+                out.push(candidate);
         }
     }
     return out;
 }
+function callerOutputCandidate(item, boundary, target, summary, liveAfter) {
+    const carriers = callerOutputCandidateCarriers(summary, liveAfter);
+    return carriers.length > 0
+        ? {
+            file: item.file,
+            line: item.line,
+            column: item.column,
+            routine: target,
+            carriers,
+            message: candidateMessage(boundary, carriers),
+        }
+        : undefined;
+}
+function callerOutputCandidateCarriers(summary, liveAfter) {
+    const intentionalOutputs = new Set(outputUnits(summary));
+    return unique([
+        ...unintentionalLiveWrites(summary, intentionalOutputs, liveAfter),
+        ...intentionalLiveOutputs(intentionalOutputs, liveAfter),
+    ]);
+}
+function unintentionalLiveWrites(summary, intentionalOutputs, liveAfter) {
+    return summary.mayWrite.filter((unit) => liveAfter.has(unit) && !intentionalOutputs.has(unit));
+}
+function intentionalLiveOutputs(intentionalOutputs, liveAfter) {
+    return [...intentionalOutputs].filter((unit) => liveAfter.has(unit));
+}

package/dist/src/register-contracts/operand-register-name.d.ts

@@ -0,0 +1,2 @@
+import type { Z80Operand } from '../z80/instruction.js';
+export declare function regName(operand: Z80Operand | undefined): string | undefined;

package/dist/src/register-contracts/operand-register-name.js

@@ -0,0 +1,13 @@
+export function regName(operand) {
+    if (operand === undefined)
+        return undefined;
+    switch (operand.kind) {
+        case 'reg8':
+        case 'reg16':
+        case 'reg-index16':
+        case 'reg-half-index':
+            return operand.register.toUpperCase();
+        default:
+            return undefined;
+    }
+}

package/dist/src/{register-care → register-contracts}/profiles.d.ts

@@ -1,14 +1,14 @@
-import type { RegisterCareUnit, RoutineSummary } from './types.js';
-export interface RegisterCareProfileSummary {
+import type { RegisterContractsUnit, RoutineSummary } from './types.js';
+export interface RegisterContractsProfileSummary {
     name: 'mon3';
     rst: Map<number, RoutineSummary>;
     rstServices: Map<string, RoutineSummary>;
     rstDispatchers: Map<number, {
-        selector: RegisterCareUnit;
+        selector: RegisterContractsUnit;
         services: Map<number, RoutineSummary>;
     }>;
 }
 export declare function rstTargetName(vector: number): string;
 export declare function rstServiceTargetName(vector: number, service: string): string;
-export declare function rstDispatcherServiceTargetNames(vector: number, selectorValue: (register: RegisterCareUnit) => number | undefined): string[];
-export declare function getRegisterCareProfile(name: 'mon3' | undefined): RegisterCareProfileSummary | undefined;
+export declare function rstDispatcherServiceTargetNames(vector: number, selectorValue: (register: RegisterContractsUnit) => number | undefined): string[];
+export declare function getRegisterContractsProfile(name: 'mon3' | undefined): RegisterContractsProfileSummary | undefined;

package/dist/src/{register-care → register-contracts}/profiles.js

@@ -95,7 +95,7 @@ function mon3ApiServices(overrides) {
     ]));
 }
 export function rstDispatcherServiceTargetNames(vector, selectorValue) {
-    const mon3 = getRegisterCareProfile('mon3');
+    const mon3 = getRegisterContractsProfile('mon3');
     const dispatcher = mon3?.rstDispatchers.get(vector);
     if (dispatcher === undefined)
         return [];
@@ -105,7 +105,7 @@ export function rstDispatcherServiceTargetNames(vector, selectorValue) {
     const service = dispatcher.services.get(value);
     return service ? [service.name] : [];
 }
-export function getRegisterCareProfile(name) {
+export function getRegisterContractsProfile(name) {
     if (name !== 'mon3')
         return undefined;
     const matrixScan = {

package/dist/src/register-contracts/programModel-boundaries.d.ts

@@ -0,0 +1,6 @@
+import type { SourceItem } from '../model/source-item.js';
+import type { RegisterContractsDirectCall } from './types.js';
+export declare function instructionCallTarget(item: SourceItem): string | undefined;
+export declare function pushDirectBoundary(boundaries: RegisterContractsDirectCall[], target: string, subject: string, file: string, line: number, column: number): void;
+export declare function collectFilesWithEntryLabels(items: readonly SourceItem[]): Set<string>;
+export declare function collectDirectTailJumps(items: readonly SourceItem[], filesWithEntryLabels: ReadonlySet<string>): RegisterContractsDirectCall[];

package/dist/src/register-contracts/programModel-boundaries.js

@@ -0,0 +1,64 @@
+function routineNameFromExpression(expression) {
+    return expression.kind === 'symbol' ? expression.name : undefined;
+}
+export function instructionCallTarget(item) {
+    if (item.kind !== 'instruction')
+        return undefined;
+    const mnemonic = item.instruction.mnemonic;
+    if (mnemonic === 'call' || mnemonic === 'call-cc') {
+        return routineNameFromExpression(item.instruction.expression);
+    }
+    return undefined;
+}
+function instructionTailJumpTarget(item, entryNames) {
+    if (item.kind !== 'instruction')
+        return undefined;
+    if (!isTailJumpInstruction(item.instruction, entryNames))
+        return undefined;
+    const target = routineNameFromExpression(item.instruction.expression);
+    return isEligibleTailJumpTarget(target, entryNames) ? target : undefined;
+}
+function isTailJumpInstruction(instruction, entryNames) {
+    return (instruction.mnemonic === 'jp' || (instruction.mnemonic === 'jp-cc' && entryNames !== undefined));
+}
+function isEligibleTailJumpTarget(target, entryNames) {
+    if (target === undefined || target.startsWith('.'))
+        return false;
+    return entryNames === undefined || entryNames.has(target);
+}
+export function pushDirectBoundary(boundaries, target, subject, file, line, column) {
+    boundaries.push({ target, subject, file, line, column });
+}
+export function collectFilesWithEntryLabels(items) {
+    return new Set(items
+        .filter((item) => item.kind === 'label')
+        .filter((item) => item.isEntry === true)
+        .map((item) => item.span.sourceName));
+}
+function entryNamesByFile(items) {
+    const namesByFile = new Map();
+    for (const item of items) {
+        if (item.kind !== 'label' || item.isEntry !== true)
+            continue;
+        const names = namesByFile.get(item.span.sourceName) ?? new Set();
+        names.add(item.name);
+        namesByFile.set(item.span.sourceName, names);
+    }
+    return namesByFile;
+}
+export function collectDirectTailJumps(items, filesWithEntryLabels) {
+    const entriesByFile = entryNamesByFile(items);
+    const directTailJumps = [];
+    for (const item of items) {
+        if (item.kind !== 'instruction')
+            continue;
+        const entryNames = filesWithEntryLabels.has(item.span.sourceName)
+            ? entriesByFile.get(item.span.sourceName)
+            : undefined;
+        const target = instructionTailJumpTarget(item, entryNames);
+        if (target === undefined)
+            continue;
+        pushDirectBoundary(directTailJumps, target, `JP ${target}`, item.span.sourceName, item.span.line, item.span.column);
+    }
+    return directTailJumps;
+}

package/dist/src/register-contracts/programModel-routines.d.ts

@@ -0,0 +1,7 @@
+import type { SourceItem } from '../model/source-item.js';
+import type { RegisterContractsDirectCall, RegisterContractsRoutine } from './types.js';
+export interface RoutineBuildResult {
+    routines: RegisterContractsRoutine[];
+    directCalls: RegisterContractsDirectCall[];
+}
+export declare function buildRoutinesAndDirectCalls(items: readonly SourceItem[], constants: ReadonlyMap<string, number>, filesWithEntryLabels: ReadonlySet<string>): RoutineBuildResult;

package/dist/src/register-contracts/programModel-routines.js

@@ -0,0 +1,128 @@
+import { instructionCallTarget, pushDirectBoundary } from './programModel-boundaries.js';
+function isGlobalLabel(name) {
+    return !name.startsWith('.');
+}
+function emptyState() {
+    return {
+        entryLabels: [],
+        labels: [],
+        instructions: [],
+    };
+}
+function toInstruction(item, labels, constants) {
+    return {
+        instruction: item.instruction,
+        file: item.span.sourceName,
+        line: item.span.line,
+        column: item.span.column,
+        labels: [...labels],
+        constants,
+    };
+}
+function startRoutine(state, item) {
+    state.sourceName = item.span.sourceName;
+    state.routineName = item.name;
+    state.entryLabels = item.isEntry === true ? [item.name] : [];
+    state.labels = [item.name];
+    state.routineStartLine = item.span.line;
+    state.routineStartColumn = item.span.column;
+    state.instructions = [];
+}
+function routineSpan(state, end) {
+    const line = state.routineStartLine ?? 1;
+    return {
+        file: state.sourceName ?? '',
+        start: { line, column: state.routineStartColumn ?? 1 },
+        end: { line: end?.line ?? line, column: end?.column ?? state.routineStartColumn ?? 1 },
+    };
+}
+function flushRoutine(routines, state, constants) {
+    if (state.routineName === undefined || state.routineStartLine === undefined)
+        return;
+    const end = state.instructions[state.instructions.length - 1];
+    routines.push({
+        name: state.routineName,
+        labels: [...state.labels],
+        entryLabels: [...state.entryLabels],
+        instructions: [...state.instructions],
+        constants,
+        span: routineSpan(state, end),
+    });
+}
+function resetAndStart(routines, state, constants, item) {
+    flushRoutine(routines, state, constants);
+    Object.assign(state, emptyState());
+    startRoutine(state, item);
+}
+function appendDirectCall(directCalls, item) {
+    const directTarget = instructionCallTarget(item);
+    if (directTarget === undefined)
+        return;
+    pushDirectBoundary(directCalls, directTarget, `CALL ${directTarget}`, item.span.sourceName, item.span.line, item.span.column);
+}
+function handleInstruction(state, directCalls, item, constants) {
+    if (state.routineName === undefined || state.sourceName === undefined)
+        return;
+    if (item.span.sourceName !== state.sourceName)
+        return;
+    state.instructions.push(toInstruction(item, state.labels, constants));
+    appendDirectCall(directCalls, item);
+}
+function handleGlobalLabel(routines, state, item, constants, filesWithEntryLabels) {
+    if (state.routineName === undefined) {
+        if (shouldIgnoreNonEntryLabel(item, filesWithEntryLabels))
+            return;
+        startRoutine(state, item);
+        return;
+    }
+    if (isDifferentRoutineSource(state, item)) {
+        resetAndStart(routines, state, constants, item);
+        return;
+    }
+    if (state.instructions.length > 0) {
+        if (shouldKeepPostInstructionAlias(item, filesWithEntryLabels)) {
+            appendRoutineLabel(state, item);
+            return;
+        }
+        resetAndStart(routines, state, constants, item);
+        return;
+    }
+    appendRoutineLabel(state, item);
+}
+function shouldIgnoreNonEntryLabel(item, filesWithEntryLabels) {
+    return filesWithEntryLabels.has(item.span.sourceName) && item.isEntry !== true;
+}
+function isDifferentRoutineSource(state, item) {
+    return state.sourceName === undefined || state.sourceName !== item.span.sourceName;
+}
+function shouldKeepPostInstructionAlias(item, filesWithEntryLabels) {
+    return shouldIgnoreNonEntryLabel(item, filesWithEntryLabels);
+}
+function appendRoutineLabel(state, item) {
+    state.labels.push(item.name);
+    if (item.isEntry === true)
+        state.entryLabels.push(item.name);
+}
+function handleLabel(routines, state, item, constants, filesWithEntryLabels) {
+    if (!isGlobalLabel(item.name)) {
+        if (state.routineName !== undefined)
+            state.labels.push(item.name);
+        return;
+    }
+    handleGlobalLabel(routines, state, item, constants, filesWithEntryLabels);
+}
+export function buildRoutinesAndDirectCalls(items, constants, filesWithEntryLabels) {
+    const routines = [];
+    const directCalls = [];
+    const state = emptyState();
+    for (const item of items) {
+        if (item.kind === 'instruction') {
+            handleInstruction(state, directCalls, item, constants);
+        }
+        else if (item.kind === 'label') {
+            handleLabel(routines, state, item, constants, filesWithEntryLabels);
+        }
+    }
+    flushRoutine(routines, state, constants);
+    return { routines, directCalls };
+}

package/dist/src/register-contracts/programModel.d.ts

@@ -0,0 +1,3 @@
+import type { SourceItem } from '../model/source-item.js';
+import type { RegisterContractsProgramModel } from './types.js';
+export declare function buildRegisterContractsProgramModel(items: readonly SourceItem[]): RegisterContractsProgramModel;

package/dist/src/register-contracts/programModel.js

@@ -0,0 +1,14 @@
+import { collectConstants } from './constants.js';
+import { collectDirectTailJumps, collectFilesWithEntryLabels } from './programModel-boundaries.js';
+import { buildRoutinesAndDirectCalls } from './programModel-routines.js';
+export function buildRegisterContractsProgramModel(items) {
+    const constants = collectConstants(items);
+    const filesWithEntryLabels = collectFilesWithEntryLabels(items);
+    const { routines, directCalls } = buildRoutinesAndDirectCalls(items, constants, filesWithEntryLabels);
+    const directTailJumps = collectDirectTailJumps(items, filesWithEntryLabels);
+    return {
+        routines,
+        directCalls,
+        directBoundaries: [...directCalls, ...directTailJumps],
+    };
+}

package/dist/src/register-contracts/report.d.ts

@@ -0,0 +1,5 @@
+import type { RegisterContractsReportModel, RegisterContractsUnit, RoutineSummary } from './types.js';
+export declare function contractCarrierList(units: RegisterContractsUnit[]): string;
+export declare function renderRegisterContractsReport(model: RegisterContractsReportModel): string;
+export declare function renderRegisterContractsInterface(summaries: RoutineSummary[]): string;
+export declare function renderRegisterContractsSourceBlock(summary: RoutineSummary): string[];

package/dist/src/{register-care → register-contracts}/report.js

@@ -71,27 +71,41 @@ function stackStatus(summary) {
 function relationOutUnits(summary) {
     return new Set(summary.valueRelations.flatMap((rel) => rel.out));
 }
-export function renderRegisterCareReport(model) {
-    const lines = ['AZM Register-Care Report', `Entry: ${model.entryFile}`, `Mode: ${model.mode}`];
+export function renderRegisterContractsReport(model) {
+    const lines = [
+        'AZM Register Contracts Report',
+        `Entry: ${model.entryFile}`,
+        `Mode: ${model.mode}`,
+    ];
     if (model.profile)
         lines.push(`Profile: ${model.profile}`);
     lines.push('');
+    appendRoutineSummaries(lines, model);
+    appendConflicts(lines, model);
+    appendOutputCandidates(lines, model);
+    appendUnknownCalls(lines, model);
+    return `${lines.join('\n')}\n`;
+}
+function appendRoutineSummaries(lines, model) {
     if (model.summaries.length === 0) {
         lines.push('Routines: none', '');
+        return;
     }
-    else {
-        for (const summary of model.summaries) {
-            lines.push(`Routine: ${summary.name}`);
-            lines.push(`  reads: ${list(summary.mayRead)}`);
-            lines.push(`  writes: ${list(summary.mayWrite)}`);
-            lines.push(`  preserves: ${list(summary.preserved)}`);
-            lines.push(`  stack: ${stackStatus(summary)}`);
-            for (const rel of summary.valueRelations) {
-                lines.push(`  relation: ${list(rel.out)} <= ${list(rel.from)}`);
-            }
-            lines.push('');
-        }
+    for (const summary of model.summaries)
+        appendRoutineSummary(lines, summary);
+}
+function appendRoutineSummary(lines, summary) {
+    lines.push(`Routine: ${summary.name}`);
+    lines.push(`  reads: ${list(summary.mayRead)}`);
+    lines.push(`  writes: ${list(summary.mayWrite)}`);
+    lines.push(`  preserves: ${list(summary.preserved)}`);
+    lines.push(`  stack: ${stackStatus(summary)}`);
+    for (const rel of summary.valueRelations) {
+        lines.push(`  relation: ${list(rel.out)} <= ${list(rel.from)}`);
     }
+    lines.push('');
+}
+function appendConflicts(lines, model) {
     lines.push('Conflicts:');
     if (model.conflicts.length === 0) {
         lines.push('  none');
@@ -102,6 +116,8 @@ export function renderRegisterCareReport(model) {
         }
     }
     lines.push('');
+}
+function appendOutputCandidates(lines, model) {
     lines.push('Output candidates:');
     if (!model.outputCandidates || model.outputCandidates.length === 0) {
         lines.push('  none');
@@ -112,6 +128,8 @@ export function renderRegisterCareReport(model) {
         }
     }
     lines.push('');
+}
+function appendUnknownCalls(lines, model) {
     lines.push('Unknown calls:');
     if (model.unknownCalls.length === 0) {
         lines.push('  none');
@@ -121,9 +139,8 @@ export function renderRegisterCareReport(model) {
             lines.push(`  ${call}`);
     }
     lines.push('');
-    return `${lines.join('\n')}\n`;
 }
-export function renderRegisterCareInterface(summaries) {
+export function renderRegisterContractsInterface(summaries) {
     const lines = [];
     for (const summary of summaries) {
         lines.push(`extern ${summary.name}`);
@@ -134,6 +151,6 @@ export function renderRegisterCareInterface(summaries) {
     }
     return `${lines.join('\n')}\n`;
 }
-export function renderRegisterCareSourceBlock(summary) {
+export function renderRegisterContractsSourceBlock(summary) {
     return sourceContractEntries(summary).map((entry) => `;!      ${entry.keyword.padEnd(10)}${entry.carriers}`);
 }

package/dist/src/register-contracts/routine-summaries.d.ts

@@ -0,0 +1,6 @@
+import type { RegisterContractsRoutine, RoutineContract, RoutineSummary } from './types.js';
+export declare function summariesWithExternalContracts(summaries: RoutineSummary[], contracts: Map<string, RoutineContract>, routineNameSet: Set<string>): RoutineSummary[];
+export declare function inferRoutineSummariesToFixedPoint(routines: RegisterContractsRoutine[], contracts: Map<string, RoutineContract>, routineNameSet: Set<string>, profileSummaries: RoutineSummary[]): Array<{
+    routine: RegisterContractsRoutine;
+    summary: RoutineSummary;
+}>;

package/dist/src/{register-care → register-contracts}/routine-summaries.js

@@ -45,6 +45,16 @@ function buildBoundarySummaryMap(summaries, routineSummaries, profileSummaries)
     }
     return boundarySummaryMap;
 }
+function buildOptimisticInternalBoundarySummaryMap(routines) {
+    const out = new Map();
+    for (const routine of routines) {
+        const summary = emptyRoutineSummary(routine.name);
+        for (const label of boundaryLabels(routine)) {
+            out.set(label, summary);
+        }
+    }
+    return out;
+}
 function summarizeRoutines(routines, contracts, boundarySummaryMap = new Map()) {
     return routines.map((routine) => {
         const inferred = inferRoutineSummary(routine, boundarySummaryMap);
@@ -73,7 +83,7 @@ function routineSummariesFingerprint(routineSummaries) {
     return routineSummaries.map((item) => summaryFingerprint(item.summary)).join('\n');
 }
 export function inferRoutineSummariesToFixedPoint(routines, contracts, routineNameSet, profileSummaries) {
-    let routineSummaries = summarizeRoutines(routines, contracts);
+    let routineSummaries = summarizeRoutines(routines, contracts, buildOptimisticInternalBoundarySummaryMap(routines));
     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, routineNameSet);

package/dist/src/register-contracts/smartCommentBlocks.d.ts

@@ -0,0 +1,5 @@
+import type { LocatedSmartComment, RegisterContractsRoutine } from './types.js';
+export declare function collectPrecedingCommentBlock(routine: RegisterContractsRoutine, sourceTexts: ReadonlyMap<string, string>): {
+    comments: LocatedSmartComment[];
+    complete: boolean;
+};