@jhlagado/azm 0.1.0

package/dist/src/registerCare/annotate.js

@@ -0,0 +1,76 @@
+import { renderRegisterCareSourceBlock } from './report.js';
+import { joinSourceLines, splitSourceLines } from './sourceText.js';
+const GENERATED_COMPACT_LINE_RE = /^\s*;\s*!\s*(?:in|out|maybe-out|clobbers|preserves)(?:\s|$)/i;
+function isCommentLine(line) {
+    return /^\s*;/.test(line);
+}
+function isGeneratedCompactLine(line) {
+    return GENERATED_COMPACT_LINE_RE.test(line);
+}
+function precedingCommentBlockStart(lines, labelIndex) {
+    let index = labelIndex - 1;
+    if (index < 0 || !isCommentLine(lines[index] ?? ''))
+        return undefined;
+    while (index >= 0 && isCommentLine(lines[index] ?? ''))
+        index -= 1;
+    return index + 1;
+}
+function generatedBlockBeforeLabel(lines, labelIndex) {
+    let compactStart = labelIndex;
+    while (compactStart > 0 && isGeneratedCompactLine(lines[compactStart - 1] ?? '')) {
+        compactStart -= 1;
+    }
+    if (compactStart < labelIndex)
+        return { start: compactStart, end: labelIndex - 1 };
+    return undefined;
+}
+function hasPrecedingCommentBlock(lines, labelIndex) {
+    return precedingCommentBlockStart(lines, labelIndex) !== undefined;
+}
+function isExplicitEntryRoutine(routine) {
+    return routine.entryLabels?.includes(routine.name) === true;
+}
+function annotateFile(source, routines) {
+    const sourceLines = splitSourceLines(source);
+    const { lines } = sourceLines;
+    const sorted = [...routines].sort((a, b) => b.routine.span.start.line - a.routine.span.start.line);
+    for (const item of sorted) {
+        const labelIndex = item.routine.span.start.line - 1;
+        if (labelIndex < 0 || labelIndex > lines.length)
+            continue;
+        const block = renderRegisterCareSourceBlock(item.summary);
+        const hasContractContent = block.length > 0;
+        const existing = generatedBlockBeforeLabel(lines, labelIndex);
+        if (existing) {
+            lines.splice(existing.start, existing.end - existing.start + 1, ...(hasContractContent ? block : []));
+            continue;
+        }
+        if (!hasContractContent)
+            continue;
+        if (!isExplicitEntryRoutine(item.routine) && !hasPrecedingCommentBlock(lines, labelIndex)) {
+            continue;
+        }
+        lines.splice(labelIndex, 0, ...block);
+    }
+    return joinSourceLines(sourceLines);
+}
+export function annotateRegisterCareContracts(sourceTexts, routines) {
+    const byFile = new Map();
+    for (const item of routines) {
+        if (!sourceTexts.has(item.routine.span.file))
+            continue;
+        const items = byFile.get(item.routine.span.file) ?? [];
+        items.push(item);
+        byFile.set(item.routine.span.file, items);
+    }
+    const out = [];
+    for (const [file, items] of [...byFile].sort(([a], [b]) => a.localeCompare(b))) {
+        const source = sourceTexts.get(file);
+        if (source === undefined)
+            continue;
+        const text = annotateFile(source, items);
+        if (text !== source)
+            out.push({ path: file, text });
+    }
+    return out;
+}

package/dist/src/registerCare/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/registerCare/boundaryHints.js

@@ -0,0 +1,10 @@
+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/src/registerCare/carriers.d.ts

@@ -0,0 +1,4 @@
+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/src/registerCare/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',
+};
+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/src/registerCare/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/registerCare/controlFlow.js

@@ -0,0 +1,35 @@
+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/src/registerCare/fix.d.ts

@@ -0,0 +1,11 @@
+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/src/registerCare/fix.js

@@ -0,0 +1,119 @@
+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/src/registerCare/liveness.d.ts

@@ -0,0 +1,7 @@
+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[];

package/dist/src/registerCare/liveness.js

@@ -0,0 +1,227 @@
+import { DiagnosticIds } from '../diagnosticTypes.js';
+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 withImpliedFlagUnits(units) {
+    return unique(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?.head.toLowerCase() === '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' ? withImpliedFlagUnits(prior.comment.carriers) : [];
+}
+function outputUnits(summary) {
+    return withImpliedFlagUnits(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 appendMapUnits(out, target, units) {
+    const existing = out.get(target) ?? [];
+    for (const unit of units) {
+        if (!existing.includes(unit))
+            existing.push(unit);
+    }
+    out.set(target, existing);
+}
+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 alreadyOutput = new Set(outputUnits(summary));
+            const carriers = unique(summary.mayWrite.filter((unit) => liveOut[index].has(unit) && !alreadyOutput.has(unit)));
+            if (carriers.length > 0) {
+                out.push({
+                    file: item.file,
+                    line: item.line,
+                    column: item.column,
+                    routine: target,
+                    carriers,
+                    message: candidateMessage(boundary, carriers),
+                });
+            }
+        }
+    }
+    return out;
+}
+export function findCallerOutputCandidates(routines, summaries) {
+    const candidates = new Map();
+    for (const item of findCallerOutputCandidateObservations(routines, summaries)) {
+        appendMapUnits(candidates, item.routine, item.carriers);
+    }
+    return candidates;
+}
+export function findAcceptedOutputCandidatesFromHints(routines, summaries, hints) {
+    const accepted = new Map();
+    for (const routine of routines) {
+        for (const { item, target } of resolvedBoundariesForRoutine(routine, summaries)) {
+            const units = hintUnitsForLine(hints, item.file, item.line);
+            if (units.length === 0)
+                continue;
+            appendMapUnits(accepted, target, units);
+        }
+    }
+    return accepted;
+}
+export function diagnosticsForRegisterCareConflicts(conflicts, severity) {
+    return conflicts.map((conflict) => ({
+        id: DiagnosticIds.RegisterCareConflict,
+        severity,
+        message: conflict.message,
+        file: conflict.file,
+        line: conflict.line,
+        column: conflict.column,
+    }));
+}

package/dist/src/registerCare/profiles.d.ts

@@ -0,0 +1,11 @@
+import type { RoutineSummary } from './types.js';
+export type RegisterCareProfileName = 'mon3';
+interface RegisterCareProfile {
+    name: RegisterCareProfileName;
+    rst: Map<number, RoutineSummary>;
+    rstServices: Map<string, RoutineSummary>;
+}
+export declare function rstTargetName(vector: number): string;
+export declare function rstServiceTargetName(vector: number, service: string): string;
+export declare function getRegisterCareProfile(name: RegisterCareProfileName | undefined): RegisterCareProfile | undefined;
+export {};

package/dist/src/registerCare/profiles.js

@@ -0,0 +1,45 @@
+const FLAG_UNITS = ['carry', 'zero', 'sign', 'parity', 'halfCarry'];
+export function rstTargetName(vector) {
+    return `RST_$${vector.toString(16).toUpperCase().padStart(2, '0')}`;
+}
+function normalizeServiceName(service) {
+    return service.replace(/[^A-Za-z0-9]/gu, '').toUpperCase();
+}
+export function rstServiceTargetName(vector, service) {
+    return `${rstTargetName(vector)}:${normalizeServiceName(service)}`;
+}
+export function getRegisterCareProfile(name) {
+    if (name !== 'mon3')
+        return undefined;
+    return {
+        name: 'mon3',
+        rst: new Map([
+            [
+                0x10,
+                {
+                    name: rstTargetName(0x10),
+                    mayRead: [],
+                    mayWrite: ['A', ...FLAG_UNITS],
+                    preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
+                    valueRelations: [],
+                    stackBalanced: true,
+                    hasUnknownStackEffect: false,
+                },
+            ],
+        ]),
+        rstServices: new Map([
+            [
+                rstServiceTargetName(0x10, 'API_SCANKEYS'),
+                {
+                    name: rstServiceTargetName(0x10, 'API_SCANKEYS'),
+                    mayRead: ['C'],
+                    mayWrite: ['sign', 'parity', 'halfCarry'],
+                    preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
+                    valueRelations: [{ out: ['A', 'carry', 'zero'], from: [] }],
+                    stackBalanced: true,
+                    hasUnknownStackEffect: false,
+                },
+            ],
+        ]),
+    };
+}

package/dist/src/registerCare/programModel.d.ts

@@ -0,0 +1,3 @@
+import type { ProgramNode } from '../frontend/ast.js';
+import type { RegisterCareProgramModel } from './types.js';
+export declare function buildRegisterCareProgramModel(program: ProgramNode): RegisterCareProgramModel;