@jhlagado/azm 0.1.1 → 0.2.0

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

@@ -0,0 +1,122 @@
+function isGlobalLabel(name) {
+    return !name.startsWith('.');
+}
+function routineNameFromExpression(expression) {
+    return expression.kind === 'symbol' ? expression.name : undefined;
+}
+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 toInstruction(item, labels) {
+    return {
+        instruction: item.instruction,
+        file: item.span.sourceName,
+        line: item.span.line,
+        column: item.span.column,
+        labels: [...labels],
+    };
+}
+export function buildRegisterCareProgramModel(items) {
+    const routines = [];
+    const directCalls = [];
+    let routineName;
+    let entryLabels = [];
+    let labels = [];
+    let sourceName;
+    let routineStartLine;
+    let routineStartColumn;
+    let instructions = [];
+    const startRoutine = (item) => {
+        sourceName = item.span.sourceName;
+        routineName = item.name;
+        entryLabels = [item.name];
+        labels = [item.name];
+        routineStartLine = item.span.line;
+        routineStartColumn = item.span.column;
+        instructions = [];
+    };
+    const flushRoutine = () => {
+        if (routineName === undefined || instructions.length === 0 || routineStartLine === undefined) {
+            return;
+        }
+        const end = instructions[instructions.length - 1];
+        if (end === undefined)
+            return;
+        routines.push({
+            name: routineName,
+            labels: [...labels],
+            entryLabels: [...entryLabels],
+            instructions: [...instructions],
+            span: {
+                file: sourceName ?? '',
+                start: { line: routineStartLine, column: routineStartColumn ?? 1 },
+                end: { line: end.line, column: end.column },
+            },
+        });
+    };
+    const resetRoutine = () => {
+        routineName = undefined;
+        entryLabels = [];
+        labels = [];
+        sourceName = undefined;
+        routineStartLine = undefined;
+        routineStartColumn = undefined;
+        instructions = [];
+    };
+    const finalizeAndRestart = (item) => {
+        flushRoutine();
+        resetRoutine();
+        startRoutine(item);
+    };
+    for (const item of items) {
+        if (item.kind !== 'label') {
+            if (item.kind !== 'instruction') {
+                continue;
+            }
+            if (routineName === undefined || sourceName === undefined) {
+                continue;
+            }
+            if (item.span.sourceName !== sourceName) {
+                continue;
+            }
+            instructions.push(toInstruction(item, labels));
+            const directTarget = instructionCallTarget(item);
+            if (directTarget !== undefined) {
+                directCalls.push({
+                    target: directTarget,
+                    file: item.span.sourceName,
+                    line: item.span.line,
+                    column: item.span.column,
+                });
+            }
+            continue;
+        }
+        if (!isGlobalLabel(item.name)) {
+            if (routineName !== undefined) {
+                labels.push(item.name);
+            }
+            continue;
+        }
+        if (routineName === undefined) {
+            startRoutine(item);
+            continue;
+        }
+        if (instructions.length > 0 ||
+            sourceName === undefined ||
+            sourceName !== item.span.sourceName) {
+            finalizeAndRestart(item);
+            continue;
+        }
+        // Multiple global labels before body on same routine are coalesced as entry labels.
+        labels.push(item.name);
+        entryLabels.push(item.name);
+    }
+    flushRoutine();
+    return { routines, directCalls };
+}

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

@@ -0,0 +1,4 @@
+import type { RegisterCareReportModel, RegisterCareUnit, RoutineSummary } from './types.js';
+export declare function renderRegisterCareReport(model: RegisterCareReportModel): string;
+export declare function contractCarrierList(units: RegisterCareUnit[]): string;
+export declare function renderRegisterCareInterface(summaries: RoutineSummary[]): string;

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

@@ -0,0 +1,82 @@
+function listUnits(units) {
+    return units.length === 0 ? '-' : units.join(',');
+}
+export function renderRegisterCareReport(model) {
+    const lines = [
+        'AZM Register-Care Report',
+        `Entry: ${model.entryFile}`,
+        `Mode: ${model.mode}`,
+        ...(model.profile !== undefined ? [`Profile: ${model.profile}`] : []),
+        '',
+    ];
+    if (model.summaries.length === 0) {
+        lines.push('Routines: none', '');
+    }
+    else {
+        for (const summary of model.summaries) {
+            lines.push(`Routine: ${summary.name}`);
+            lines.push(`  reads: ${listUnits(summary.mayRead)}`);
+            lines.push(`  writes: ${listUnits(summary.mayWrite)}`);
+            lines.push(`  preserves: ${listUnits(summary.preserved)}`);
+            lines.push('');
+        }
+    }
+    lines.push('Conflicts:');
+    if (model.conflicts.length === 0) {
+        lines.push('  none');
+    }
+    else {
+        for (const conflict of model.conflicts) {
+            lines.push(`  ${conflict.file}:${conflict.line}:${conflict.column}: ${conflict.callTarget}: ${conflict.message}`);
+        }
+    }
+    lines.push('');
+    lines.push('Output candidates:');
+    if (model.outputCandidates === undefined || model.outputCandidates.length === 0) {
+        lines.push('  none');
+    }
+    else {
+        for (const candidate of model.outputCandidates) {
+            lines.push(`  ${candidate.file}:${candidate.line}:${candidate.column}: ${candidate.routine}: ${candidate.carriers.join(',')}: ${candidate.message}`);
+        }
+    }
+    lines.push('');
+    lines.push('Unknown calls:');
+    if (model.unknownCalls.length === 0) {
+        lines.push('  none');
+    }
+    else {
+        for (const call of model.unknownCalls) {
+            lines.push(`  ${call}`);
+        }
+    }
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+export function contractCarrierList(units) {
+    return units.length === 0 ? '-' : units.join(',');
+}
+export function renderRegisterCareInterface(summaries) {
+    const lines = [];
+    for (const summary of summaries) {
+        if (summary.mayRead.length === 0 &&
+            summary.mayWrite.length === 0 &&
+            summary.preserved.length === 0) {
+            continue;
+        }
+        lines.push(`extern ${summary.name}`);
+        if (summary.mayRead.length > 0) {
+            lines.push(`in ${contractCarrierList(summary.mayRead)}`);
+        }
+        if (summary.mayWrite.length > 0) {
+            lines.push(`clobbers ${contractCarrierList(summary.mayWrite)}`);
+        }
+        if (summary.preserved.length > 0) {
+            lines.push(`preserves ${contractCarrierList(summary.preserved)}`);
+        }
+        lines.push('end', '');
+    }
+    if (lines.length === 0)
+        lines.push('No inferred contracts were emitted.', '');
+    return `${lines.join('\n')}\n`;
+}

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

@@ -0,0 +1,5 @@
+import type { LocatedSmartComment, RegisterCareRoutine, RoutineContract, SmartComment } from './types.js';
+export declare function parseSmartCommentLine(line: string): SmartComment | undefined;
+export declare function parseSmartComments(sourceLineComments: ReadonlyMap<string, ReadonlyMap<number, string>>): LocatedSmartComment[];
+export declare function buildRoutineContracts(comments: LocatedSmartComment[], routines?: RegisterCareRoutine[], sourceTexts?: ReadonlyMap<string, string>): Map<string, RoutineContract>;
+export declare function parseInterfaceContracts(text: string, file?: string): Map<string, RoutineContract>;

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

@@ -0,0 +1,243 @@
+import { expandCarrierList } from './carriers.js';
+const COMPACT_SOURCE_TAG_RE = /^;?\s*!\s*(in|out|clobbers|preserves)(?:\s+(.+))?$/i;
+const COMPACT_SOURCE_LINE_RE = /^\s*;\s*!\s*(?:in|out|maybe-out|clobbers|preserves)(?:\s|$)/i;
+const INTERFACE_TAG_RE = /^\s*(in|out|clobbers|preserves)(?:\s+(.+))?$/i;
+const CARRIER_RE = /^\{([^}]+)\}(?:\s+(.+))?$/;
+function parseCarrierPayload(rest) {
+    if (!rest)
+        return undefined;
+    const match = CARRIER_RE.exec(rest.trim());
+    if (match) {
+        const carriers = match[1].split(',').map((value) => value.trim()).filter(Boolean);
+        const name = match[2]?.trim();
+        return { carriers, ...(name ? { name } : {}) };
+    }
+    const tokens = rest.trim().split(/\s+/u);
+    const carriers = [];
+    let consumed = 0;
+    for (const token of tokens) {
+        const cleaned = token.replace(/[.:;]+$/u, '');
+        const parts = cleaned
+            .split(',')
+            .map((value) => value.trim())
+            .filter(Boolean);
+        if (parts.length === 0 || !expandCarrierList(parts))
+            break;
+        carriers.push(...parts);
+        consumed += 1;
+    }
+    if (carriers.length === 0)
+        return undefined;
+    const name = tokens.slice(consumed).join(' ').trim();
+    return { carriers, ...(name ? { name } : {}) };
+}
+export function parseSmartCommentLine(line) {
+    const trimmed = line.trim();
+    const expectOut = /^;?\s*expects\s+out\s+(.+)$/i.exec(trimmed);
+    if (expectOut !== null) {
+        const payload = parseCarrierPayload(expectOut[1]?.trim());
+        if (!payload)
+            return undefined;
+        const carriers = expandCarrierList(payload.carriers);
+        if (!carriers || carriers.length === 0)
+            return undefined;
+        return { kind: 'expectOut', carriers, ...(payload.name ? { name: payload.name } : {}) };
+    }
+    const match = COMPACT_SOURCE_TAG_RE.exec(trimmed);
+    if (!match)
+        return undefined;
+    const tag = match[1].toLowerCase();
+    const rest = match[2]?.trim();
+    const payload = parseCarrierPayload(rest);
+    if (!payload)
+        return undefined;
+    const carriers = expandCarrierList(payload.carriers);
+    if (!carriers || carriers.length === 0)
+        return undefined;
+    if (tag === 'in')
+        return { kind: 'in', carriers, ...(payload.name ? { name: payload.name } : {}) };
+    if (tag === 'out')
+        return { kind: 'out', carriers, ...(payload.name ? { name: payload.name } : {}) };
+    if (tag === 'clobbers')
+        return { kind: 'clobbers', carriers };
+    if (tag === 'preserves')
+        return { kind: 'preserves', carriers };
+    return undefined;
+}
+function parseInterfaceContractLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith(';'))
+        return undefined;
+    const extern = /^extern\s+(\S+)\s*$/i.exec(trimmed);
+    if (extern !== null)
+        return { kind: 'extern', name: extern[1] };
+    if (/^end\s*$/i.test(trimmed))
+        return { kind: 'end' };
+    const match = INTERFACE_TAG_RE.exec(trimmed);
+    if (!match)
+        return undefined;
+    const tag = match[1].toLowerCase();
+    const rest = match[2]?.trim();
+    if (!rest)
+        return undefined;
+    const rawCarriers = rest.split(',').map((part) => part.trim());
+    if (rawCarriers.length === 0 || rawCarriers.some((part) => part.length === 0))
+        return undefined;
+    const carriers = expandCarrierList(rawCarriers);
+    if (!carriers || carriers.length === 0)
+        return undefined;
+    if (tag === 'in')
+        return { kind: 'in', carriers };
+    if (tag === 'out')
+        return { kind: 'out', carriers };
+    if (tag === 'clobbers')
+        return { kind: 'clobbers', carriers };
+    if (tag === 'preserves')
+        return { kind: 'preserves', carriers };
+    return undefined;
+}
+function isCompactSourceCommentLine(line) {
+    return COMPACT_SOURCE_LINE_RE.test(line);
+}
+export function parseSmartComments(sourceLineComments) {
+    const out = [];
+    for (const [file, comments] of sourceLineComments) {
+        for (const [line, text] of comments) {
+            const parsed = parseSmartCommentLine(`;${text}`);
+            if (parsed) {
+                out.push({ file, line, comment: parsed });
+            }
+        }
+    }
+    return out.sort((a, b) => (a.file === b.file ? a.line - b.line : a.file.localeCompare(b.file)));
+}
+function appendUnique(items, values) {
+    for (const value of values) {
+        if (!items.includes(value)) {
+            items.push(value);
+        }
+    }
+}
+function isCommentOnlyLine(line) {
+    return /^\s*;/.test(line);
+}
+function applyContractComment(contract, comment) {
+    if (comment.kind === 'in')
+        appendUnique(contract.in, comment.carriers);
+    if (comment.kind === 'out')
+        appendUnique(contract.out, comment.carriers);
+    if (comment.kind === 'clobbers')
+        appendUnique(contract.clobbers, comment.carriers);
+    if (comment.kind === 'preserves')
+        appendUnique(contract.preserves, comment.carriers);
+}
+function hasContractContent(contract) {
+    return (contract.in.length > 0 ||
+        contract.out.length > 0 ||
+        contract.clobbers.length > 0 ||
+        contract.preserves.length > 0);
+}
+function collectPrecedingCommentBlock(routine, sourceTexts) {
+    const source = sourceTexts.get(routine.span.file);
+    if (source === undefined)
+        return { comments: [], complete: false };
+    const lines = source.split(/\r?\n/);
+    const rawBlock = [];
+    for (let index = routine.span.start.line - 2; index >= 0; index -= 1) {
+        const text = lines[index] ?? '';
+        if (!isCommentOnlyLine(text))
+            break;
+        rawBlock.push({ line: index + 1, text });
+    }
+    rawBlock.reverse();
+    let compactStart = rawBlock.length;
+    while (compactStart > 0 &&
+        isCompactSourceCommentLine(rawBlock[compactStart - 1]?.text ?? '')) {
+        compactStart -= 1;
+    }
+    return {
+        complete: compactStart < rawBlock.length,
+        comments: (compactStart < rawBlock.length ? rawBlock.slice(compactStart) : rawBlock).flatMap((item) => {
+            const parsed = parseSmartCommentLine(item.text);
+            return parsed ? [{ file: routine.span.file, line: item.line, comment: parsed }] : [];
+        }),
+    };
+}
+function buildImplicitRoutineContracts(routines, sourceTexts) {
+    const contracts = new Map();
+    for (const routine of routines) {
+        const docBlock = collectPrecedingCommentBlock(routine, sourceTexts);
+        if (docBlock.comments.some((item) => item.comment.kind === 'extern' || item.comment.kind === 'end')) {
+            continue;
+        }
+        const contract = {
+            name: routine.name,
+            in: [],
+            out: [],
+            clobbers: [],
+            preserves: [],
+            ...(docBlock.complete ? { complete: true } : {}),
+        };
+        for (const item of docBlock.comments) {
+            applyContractComment(contract, item.comment);
+        }
+        if (hasContractContent(contract)) {
+            contracts.set(routine.name, contract);
+        }
+    }
+    return contracts;
+}
+export function buildRoutineContracts(comments, routines = [], sourceTexts = new Map()) {
+    const contracts = new Map();
+    let current;
+    for (const item of comments) {
+        if (item.comment.kind === 'extern') {
+            current = {
+                name: item.comment.name,
+                in: [],
+                out: [],
+                clobbers: [],
+                preserves: [],
+            };
+            contracts.set(item.comment.name, current);
+            continue;
+        }
+        if (item.comment.kind === 'end') {
+            current = undefined;
+            continue;
+        }
+        if (current !== undefined) {
+            applyContractComment(current, item.comment);
+        }
+    }
+    for (const [name, contract] of buildImplicitRoutineContracts(routines, sourceTexts)) {
+        if (!contracts.has(name)) {
+            contracts.set(name, contract);
+        }
+    }
+    return contracts;
+}
+export function parseInterfaceContracts(text, file = '<register-care-interface>') {
+    const comments = [];
+    const lines = text.split(/\r?\n/u);
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        if (trimmed.startsWith(';')) {
+            throw new Error(`${file}:${index + 1}: .asmi files do not permit comments`);
+        }
+        const comment = parseInterfaceContractLine(line);
+        if (comment === undefined) {
+            throw new Error(`${file}:${index + 1}: invalid register-care interface line \"${trimmed}\"`);
+        }
+        comments.push({ file, line: index + 1, comment });
+    }
+    const routines = buildRoutineContracts(comments);
+    const out = new Map();
+    for (const [name, contract] of routines) {
+        if (hasContractContent(contract))
+            out.set(name, contract);
+    }
+    return out;
+}

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

@@ -0,0 +1,12 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { AnalyzeRegisterCareOptions, RegisterCareDirectCall, RegisterCareRoutine, RoutineContract, RoutineSummary, RegisterCareUnit, RegisterCareOutputCandidate } from './types.js';
+export declare function buildProfileSummaries(profileName: AnalyzeRegisterCareOptions['registerCareProfile']): RoutineSummary[];
+export declare function buildProfileSummaryLookup(profileName: AnalyzeRegisterCareOptions['registerCareProfile']): Map<string, RoutineSummary>;
+export declare function routineNames(routines: readonly RegisterCareRoutine[]): string[];
+export declare function buildSummaries(routines: readonly RegisterCareRoutine[], contractMap: Map<string, RoutineContract>): RoutineSummary[];
+export declare function buildSummaryByName(routines: readonly RegisterCareRoutine[], summaries: readonly RoutineSummary[], profileSummaries?: readonly RoutineSummary[]): Map<string, RoutineSummary>;
+export declare function withAcceptedOutputs(summaries: readonly RoutineSummary[], acceptedOutputCandidates: ReadonlyMap<string, RegisterCareUnit[]> | undefined): RoutineSummary[];
+export declare function unknownBoundaryDiagnostics(directCalls: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): Diagnostic[];
+export declare function unknownCallList(directCalls: readonly RegisterCareDirectCall[], knownRoutines: ReadonlySet<string>): string[];
+export declare function buildOutputCandidateFixability(routines: readonly RegisterCareRoutine[], outputCandidates: readonly RegisterCareOutputCandidate[], autoFixableCandidateKeys: (routines: RegisterCareRoutine[], outputCandidates: RegisterCareOutputCandidate[]) => ReadonlySet<string>): ReadonlyMap<string, boolean>;
+export declare function outputCandidateKey(file: string, line: number, column: number): string;

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

@@ -0,0 +1,154 @@
+import { getRegisterCareProfile } from './profiles.js';
+import { getZ80InstructionEffect } from '../z80/effects.js';
+function unique(values) {
+    const out = [];
+    for (const value of values) {
+        if (!out.includes(value))
+            out.push(value);
+    }
+    return out;
+}
+function inferRoutineSummary(routine) {
+    const reads = new Set();
+    const writes = new Set();
+    for (const instruction of routine.instructions) {
+        const effect = getZ80InstructionEffect(instruction.instruction);
+        for (const unit of effect.reads)
+            reads.add(unit);
+        for (const unit of effect.writes)
+            writes.add(unit);
+    }
+    return {
+        name: routine.name,
+        mayRead: Array.from(reads),
+        mayWrite: Array.from(writes),
+        preserved: [],
+    };
+}
+export function buildProfileSummaries(profileName) {
+    const profile = getRegisterCareProfile(profileName);
+    if (profile === undefined) {
+        return [];
+    }
+    return [...profile.rst.values(), ...profile.rstServices.values()];
+}
+export function buildProfileSummaryLookup(profileName) {
+    const profile = getRegisterCareProfile(profileName);
+    const out = new Map();
+    if (profile === undefined)
+        return out;
+    for (const summary of profile.rst.values()) {
+        out.set(summary.name, summary);
+    }
+    for (const summary of profile.rstServices.values()) {
+        out.set(summary.name, summary);
+    }
+    return out;
+}
+export function routineNames(routines) {
+    return routines.flatMap((routine) => routine.entryLabels.length > 0 ? routine.entryLabels : [routine.name]);
+}
+function entryContract(routine, contractMap) {
+    for (const label of routine.entryLabels.length > 0 ? routine.entryLabels : [routine.name]) {
+        const contract = contractMap.get(label);
+        if (contract !== undefined)
+            return contract;
+    }
+    return contractMap.get(routine.name);
+}
+export function buildSummaries(routines, contractMap) {
+    const out = [];
+    const written = new Set();
+    for (const routine of routines) {
+        const inferred = inferRoutineSummary(routine);
+        const contract = entryContract(routine, contractMap);
+        out.push({
+            name: routine.name,
+            mayRead: unique([...inferred.mayRead, ...(contract?.in ?? [])]),
+            mayWrite: unique([
+                ...inferred.mayWrite,
+                ...(contract?.out ?? []),
+                ...(contract?.clobbers ?? []),
+            ]),
+            preserved: unique([...inferred.preserved, ...(contract?.preserves ?? [])]),
+        });
+        written.add(routine.name);
+        for (const alias of routine.entryLabels)
+            written.add(alias);
+    }
+    for (const [name, contract] of contractMap) {
+        if (written.has(name))
+            continue;
+        out.push({
+            name,
+            mayRead: [...contract.in],
+            mayWrite: [...contract.out, ...contract.clobbers],
+            preserved: [...contract.preserves],
+        });
+        written.add(name);
+    }
+    return out;
+}
+export function buildSummaryByName(routines, summaries, profileSummaries = []) {
+    const out = new Map();
+    const byRoutine = new Map();
+    for (const summary of summaries) {
+        byRoutine.set(summary.name, summary);
+        out.set(summary.name, summary);
+    }
+    for (const summary of profileSummaries) {
+        out.set(summary.name, summary);
+    }
+    for (const routine of routines) {
+        const routineSummary = byRoutine.get(routine.name);
+        if (routineSummary === undefined)
+            continue;
+        for (const alias of routine.entryLabels.length > 0 ? routine.entryLabels : [routine.name]) {
+            out.set(alias, routineSummary);
+        }
+    }
+    return out;
+}
+export function withAcceptedOutputs(summaries, acceptedOutputCandidates) {
+    if (!acceptedOutputCandidates || acceptedOutputCandidates.size === 0) {
+        return [...summaries];
+    }
+    return summaries.map((summary) => {
+        const accepted = acceptedOutputCandidates.get(summary.name);
+        if (!accepted || accepted.length === 0) {
+            return summary;
+        }
+        const merged = unique([...summary.mayWrite, ...accepted]);
+        return {
+            ...summary,
+            mayWrite: merged,
+            mayOutput: unique([...accepted]),
+        };
+    });
+}
+export function unknownBoundaryDiagnostics(directCalls, knownRoutines) {
+    return directCalls
+        .filter((call) => !knownRoutines.has(call.target))
+        .map((call) => ({
+        severity: 'warning',
+        code: 'AZMN_REGISTER_CARE',
+        message: `Register-care cannot prove ${call.target}; add a routine body or .asmi extern contract.`,
+        sourceName: call.file,
+        line: call.line,
+        column: call.column,
+    }));
+}
+export function unknownCallList(directCalls, knownRoutines) {
+    return unique(directCalls.filter((call) => !knownRoutines.has(call.target)).map((call) => call.target)).sort();
+}
+export function buildOutputCandidateFixability(routines, outputCandidates, autoFixableCandidateKeys) {
+    const autoFixable = autoFixableCandidateKeys([...routines], [...outputCandidates]);
+    const out = new Map();
+    for (const candidate of outputCandidates) {
+        out.set(outputCandidateKey(candidate.file, candidate.line, candidate.column), autoFixable.has(outputCandidateKey(candidate.file, candidate.line, candidate.column)));
+    }
+    return out;
+}
+export function outputCandidateKey(file, line, column) {
+    return `${file}:${line}:${column}`;
+}

package/dist/src/{registerCare → register-care}/tooling.d.ts

@@ -1,7 +1,6 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { LoadedProgram } from '../sourceLoader.js';
-import { type AnalyzeRegisterCareOptions } from './analyze.js';
-import type { RegisterCareOutputCandidate, RegisterCareUnit } from './types.js';
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { LoadedProgram } from '../tooling/api.js';
+import type { AnalyzeRegisterCareOptions, RegisterCareOutputCandidate, RegisterCareUnit } from './types.js';
 export interface RegisterCareTextEdit {
     file: string;
     line: number;
@@ -23,11 +22,13 @@ export interface RegisterCareCandidateDiagnostic {
     carriers: RegisterCareUnit[];
     autoFixable: boolean;
     message: string;
-    codeAction: RegisterCareCodeAction;
+    codeAction?: RegisterCareCodeAction;
 }
-export interface AnalyzeRegisterCareForToolsOptions extends Omit<AnalyzeRegisterCareOptions, 'emitReport' | 'emitInterface' | 'emitAnnotations'> {
+export interface AnalyzeRegisterCareForToolsOptions extends Omit<AnalyzeRegisterCareOptions, 'emitReport' | 'emitInterface' | 'emitAnnotations' | 'fixRegisterContracts'> {
     emitReport?: boolean;
     emitInterface?: boolean;
+    /** Back-compat alias for registerCareProfile used by some tooling integrations. */
+    profile?: AnalyzeRegisterCareOptions['registerCareProfile'];
 }
 export interface AnalyzeRegisterCareForToolsResult {
     diagnostics: Diagnostic[];