@jhlagado/azm 0.1.1 → 0.2.0

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

@@ -0,0 +1,154 @@
+function formatCarrierLine(tag, units) {
+    return `;!      ${tag.padEnd(10)}${units.join(',')}`;
+}
+function formatCandidateUnits(units) {
+    return units.length === 1 ? units[0] : `{${units.join(',')}}`;
+}
+function formatCarrierLineWithExpectOut(indentation, units) {
+    return `${indentation}; expects out ${formatCandidateUnits(units)}`;
+}
+function formatCarrierLineWithMaybeOut(indentation, units) {
+    return `${indentation};!      ${'maybe-out'.padEnd(10)}${formatCandidateUnits(units)}`;
+}
+function isGeneratedRegisterContractLine(line) {
+    return /^\s*;!\s*(in|out|clobbers|preserves|maybe-out)\b/i.test(line);
+}
+function isOutputCandidateHintLine(line) {
+    return /^\s*;\s*expects\s+out\b/i.test(line) || /^\s*;\s*!\s*maybe-out\b/i.test(line);
+}
+function normalizeLineEnding(text) {
+    return text.replace(/\r\n/g, '\n');
+}
+function splitSourceLines(text) {
+    return normalizeLineEnding(text).split('\n');
+}
+function lineDeltaForCandidate(line, deltas) {
+    let shift = 0;
+    for (const delta of deltas) {
+        if (delta.anchorLine < line) {
+            shift += delta.delta;
+        }
+    }
+    return shift;
+}
+function applyOutputCandidateHints(sourceText, outputCandidates, candidateFixability, deltas, outputCandidateKey) {
+    const lines = splitSourceLines(sourceText);
+    const grouped = new Map();
+    for (const candidate of outputCandidates) {
+        const adjustedLine = candidate.line + lineDeltaForCandidate(candidate.line, deltas);
+        const existing = grouped.get(adjustedLine);
+        const autoFixable = candidateFixability.get(outputCandidateKey(candidate.file, candidate.line, candidate.column)) ?? false;
+        if (existing === undefined) {
+            grouped.set(adjustedLine, { carriers: [...candidate.carriers], autoFixable });
+            continue;
+        }
+        const carriers = existing.carriers;
+        for (const carrier of candidate.carriers) {
+            if (!carriers.includes(carrier)) {
+                carriers.push(carrier);
+            }
+        }
+        existing.autoFixable = existing.autoFixable && autoFixable;
+    }
+    const candidates = [...grouped.entries()]
+        .map(([line, entry]) => ({ line, ...entry }))
+        .sort((left, right) => right.line - left.line);
+    for (const candidate of candidates) {
+        const index = candidate.line - 1;
+        if (index < 0 || index > lines.length)
+            continue;
+        if (index > 0 && isOutputCandidateHintLine(lines[index - 1] ?? ''))
+            continue;
+        const indentation = lines[index]?.match(/^\s*/)?.[0] ?? '';
+        const hint = candidate.autoFixable
+            ? formatCarrierLineWithExpectOut(indentation, candidate.carriers)
+            : formatCarrierLineWithMaybeOut(indentation, candidate.carriers);
+        lines.splice(index, 0, hint);
+    }
+    return lines.join('\n');
+}
+function annotateSourceFile(sourceText, routines, summariesByName) {
+    const routineLines = Array.from(routines)
+        .filter((routine) => summariesByName.has(routine.name))
+        .sort((left, right) => right.span.start.line - left.span.start.line);
+    if (routineLines.length === 0)
+        return undefined;
+    const lines = splitSourceLines(sourceText);
+    let changed = false;
+    const deltas = [];
+    for (const routine of routineLines) {
+        const summary = summariesByName.get(routine.name);
+        if (!summary)
+            continue;
+        const insertLine = routine.span.start.line - 1;
+        if (insertLine < 0 || insertLine > lines.length)
+            continue;
+        const generatedLines = [
+            ...(summary.mayRead.length > 0 ? [formatCarrierLine('in', summary.mayRead)] : []),
+            ...(summary.mayWrite.length > 0 ? [formatCarrierLine('out', summary.mayWrite)] : []),
+            ...(summary.preserved.length > 0 ? [formatCarrierLine('preserves', summary.preserved)] : []),
+        ];
+        if (generatedLines.length === 0)
+            continue;
+        let start = insertLine;
+        for (let index = insertLine - 1; index >= 0 && isGeneratedRegisterContractLine(lines[index] ?? ''); index -= 1) {
+            start = index;
+        }
+        if (start === insertLine ||
+            lines.slice(start, insertLine).some((line) => line.trim().length === 0)) {
+            start = insertLine;
+        }
+        const existing = lines.slice(start, insertLine);
+        if (existing.length !== generatedLines.length ||
+            existing.some((line, index) => line !== generatedLines[index])) {
+            changed = true;
+            deltas.push({
+                anchorLine: routine.span.start.line,
+                delta: generatedLines.length - (insertLine - start),
+            });
+            lines.splice(start, insertLine - start, ...generatedLines);
+        }
+    }
+    if (!changed)
+        return undefined;
+    return {
+        text: lines.join('\n'),
+        deltas,
+    };
+}
+export function buildAnnotations(loaded, programRoutines, summariesByName, outputCandidates, options) {
+    const byFile = new Map();
+    for (const routine of programRoutines) {
+        if (!summariesByName.has(routine.name))
+            continue;
+        const file = byFile.get(routine.span.file);
+        if (file === undefined) {
+            byFile.set(routine.span.file, [routine]);
+        }
+        else {
+            file.push(routine);
+        }
+    }
+    const out = [];
+    for (const [path, routines] of byFile) {
+        const sourceText = loaded.sourceTexts.get(path);
+        if (sourceText === undefined)
+            continue;
+        let text = sourceText;
+        let deltas = [];
+        const annotation = annotateSourceFile(sourceText, routines, summariesByName);
+        if (annotation !== undefined) {
+            text = annotation.text;
+            deltas = annotation.deltas;
+        }
+        if (options.fixOutputCandidates) {
+            const candidatesForFile = outputCandidates.filter((candidate) => candidate.file === path);
+            if (candidatesForFile.length > 0) {
+                text = applyOutputCandidateHints(text, candidatesForFile, options.outputCandidateFixability, deltas, options.outputCandidateKey);
+            }
+        }
+        if (text !== sourceText)
+            out.push({ path, text });
+    }
+    return out;
+}

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,9 @@
+import type { RegisterCareOutputCandidate, RegisterCareRoutine, RegisterCareUnit } from './types.js';
+export interface RegisterCareExpectOutFix {
+    file: string;
+    line: number;
+    column: number;
+    routine: string;
+    carriers: RegisterCareUnit[];
+}
+export declare function autoFixableCandidateKeys(routines: RegisterCareRoutine[], candidates: RegisterCareOutputCandidate[]): Set<string>;

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

@@ -0,0 +1,78 @@
+import { getZ80InstructionEffect } from '../z80/effects.js';
+import { instructionSuccessors, labelIndex } from './controlFlow.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 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;
+}

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,189 @@
+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) ?? []),
+        ...(summary.mayOutput ?? []),
+    ]);
+}
+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 && !boundary.conditional) {
+            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 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;
+}

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

@@ -0,0 +1,9 @@
+import type { RoutineSummary } from './types.js';
+export interface RegisterCareProfileSummary {
+    name: 'mon3';
+    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: 'mon3' | undefined): RegisterCareProfileSummary | undefined;

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

@@ -0,0 +1,43 @@
+const FLAG_UNITS = ['carry', 'zero', 'sign', 'parity', 'halfCarry'];
+export function rstTargetName(vector) {
+    return `RST_$${vector.toString(16).toUpperCase().padStart(2, '0')}`;
+}
+function normalizeServiceName(raw) {
+    return raw.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],
+                    mayOutput: [],
+                    preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
+                    valueRelations: [],
+                },
+            ],
+        ]),
+        rstServices: new Map([
+            [
+                rstServiceTargetName(0x10, 'API_SCANKEYS'),
+                {
+                    name: rstServiceTargetName(0x10, 'API_SCANKEYS'),
+                    mayRead: ['C'],
+                    mayWrite: ['sign', 'parity', 'halfCarry'],
+                    mayOutput: ['A', 'carry', 'zero'],
+                    preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
+                    valueRelations: [{ out: ['A', 'carry', 'zero'], from: [] }],
+                },
+            ],
+        ]),
+    };
+}

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

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