@jhlagado/azm 0.2.7 → 0.2.9

package/dist/src/cli/parse-args.js

@@ -1,38 +1,58 @@
 import { readFileSync } from 'node:fs';
 import { extname } from 'node:path';
-export function cliUsage() {
-    return [
-        'azm [options] <entry.asm|entry.z80>',
-        '',
-        'Options:',
-        '  -o, --output <file>   Primary output path (must match --type extension)',
-        '  -t, --type <type>     Primary output type: hex|bin (default: hex)',
-        '      --nobin           Suppress .bin',
-        '      --nohex           Suppress .hex',
-        '      --nod8m           Suppress .d8.json',
-        '      --asm80           Emit lowered source (.z80)',
-        '      --register-care    Register-care mode: off|audit|warn|error|strict',
-        '      --rc <m>           Register-care mode alias for --register-care',
-        '      --reg-report       Emit register-care report artifact',
-        '      --reg-interface     Emit inferred register-care interface (.asmi)',
-        '      --contracts        Rewrite source with inferred register-care contracts',
-        '      --fix              Enable contract rewrite and conservative fixes',
-        '      --accept-out <x>   Accept register-care output candidates',
-        '      --interface <file>  Load .asmi contract file',
-        '      --reg-profile <p>  Register-care profile (currently mon3)',
-        '      --source-root <d> Normalize D8 source paths relative to this directory',
-        '      --case-style <m>  Case-style lint mode: off|upper|lower|consistent',
-        '      --aliases <file>  Load project directive alias JSON (repeatable)',
-        '  -I, --include <dir>   Add include search path (repeatable)',
-        '  -V, --version         Print version',
-        '  -h, --help            Show help',
-        '',
-        'Notes:',
-        '  - <entry.asm|entry.z80> must be the last argument (assembler-style).',
-        '  - Output artifacts are written using the primary output stem with standard suffixes.',
-        '',
-    ].join('\n');
-}
+import { cliUsage } from './usage.js';
+const BOOLEAN_FLAG_ACTIONS = [
+    {
+        flags: ['--nobin'],
+        apply: (state) => {
+            state.emitBin = false;
+        },
+    },
+    {
+        flags: ['--nohex'],
+        apply: (state) => {
+            state.emitHex = false;
+        },
+    },
+    {
+        flags: ['--nod8m'],
+        apply: (state) => {
+            state.emitD8m = false;
+        },
+    },
+    {
+        flags: ['--asm80'],
+        apply: (state) => {
+            state.emitAsm80 = true;
+        },
+    },
+    {
+        flags: ['--emit-register-report', '--reg-report'],
+        apply: (state) => {
+            state.emitRegisterReport = true;
+        },
+    },
+    {
+        flags: ['--emit-register-interface', '--reg-interface'],
+        apply: (state) => {
+            state.emitRegisterInterface = true;
+        },
+    },
+    {
+        flags: ['--fix'],
+        apply: (state) => {
+            state.fixRegisterContracts = true;
+            state.emitRegisterAnnotations = true;
+        },
+    },
+    {
+        flags: ['--contracts', '--annotate-register-contracts'],
+        apply: (state) => {
+            state.emitRegisterAnnotations = true;
+        },
+    },
+];
+export { cliUsage };
 function fail(message) {
     throw new Error(message);
 }
@@ -45,13 +65,13 @@ function createDefaultCliState() {
         emitD8m: true,
         emitAsm80: false,
         caseStyle: 'off',
-        registerCare: 'off',
+        registerContracts: 'off',
         emitRegisterReport: false,
         emitRegisterInterface: false,
         emitRegisterAnnotations: false,
         fixRegisterContracts: false,
         acceptRegisterOutputCandidates: [],
-        registerCareInterfaces: [],
+        registerContractsInterfaces: [],
         sourceRoot: undefined,
         includeDirs: [],
         directiveAliasFiles: [],
@@ -89,7 +109,9 @@ function parseOutputPathArg(arg, argv, indexRef, state) {
 function parseOutputTypeArg(arg, argv, indexRef, state) {
     if (arg !== '-t' && arg !== '--type' && !arg.startsWith('--type='))
         return false;
-    const value = arg.startsWith('--type=') ? arg.slice('--type='.length) : readValue(argv, indexRef, '--type');
+    const value = arg.startsWith('--type=')
+        ? arg.slice('--type='.length)
+        : readValue(argv, indexRef, '--type');
     if (!value) {
         fail('--type expects a value');
     }
@@ -148,8 +170,12 @@ function readMatchedFlagValue(arg, argv, indexRef, flags) {
     }
     return { flag, value };
 }
-function parseRegisterCareArg(arg, argv, indexRef, state) {
-    const parsed = readMatchedFlagValue(arg, argv, indexRef, ['--register-care', '--rc']);
+function parseRegisterContractsArg(arg, argv, indexRef, state) {
+    const parsed = readMatchedFlagValue(arg, argv, indexRef, [
+        '--register-contracts',
+        '--register-care',
+        '--rc',
+    ]);
     if (!parsed)
         return false;
     const { value, flag } = parsed;
@@ -160,7 +186,7 @@ function parseRegisterCareArg(arg, argv, indexRef, state) {
         value !== 'strict') {
         fail(`Unsupported ${flag} "${value}" (expected off|audit|warn|error|strict)`);
     }
-    state.registerCare = value;
+    state.registerContracts = value;
     return true;
 }
 function parseRegisterProfileArg(arg, argv, indexRef, state) {
@@ -170,7 +196,7 @@ function parseRegisterProfileArg(arg, argv, indexRef, state) {
     if (parsed.value !== 'mon3') {
         fail(`Unsupported ${parsed.flag} "${parsed.value}" (expected mon3)`);
     }
-    state.registerCareProfile = parsed.value;
+    state.registerContractsProfile = parsed.value;
     return true;
 }
 function parseRegisterInterfaceArg(arg, argv, indexRef, state) {
@@ -181,7 +207,7 @@ function parseRegisterInterfaceArg(arg, argv, indexRef, state) {
         : readValue(argv, indexRef, '--interface');
     if (!value)
         fail('--interface expects a value');
-    state.registerCareInterfaces.push(value);
+    state.registerContractsInterfaces.push(value);
     return true;
 }
 function parseAcceptOutputArg(arg, argv, indexRef, state) {
@@ -211,58 +237,116 @@ function handleFastPath(arg) {
     }
     return undefined;
 }
+function cliOptionOutputPath(state) {
+    return state.outputPath ? { outputPath: state.outputPath } : {};
+}
+function cliOptionSourceRoot(state) {
+    return state.sourceRoot !== undefined ? { sourceRoot: state.sourceRoot } : {};
+}
+function cliOptionRegisterContractsProfile(state) {
+    return state.registerContractsProfile !== undefined
+        ? { registerContractsProfile: state.registerContractsProfile }
+        : {};
+}
 function finalizeCliOptions(state) {
-    if (!state.entryFile) {
-        fail(`Expected exactly one <entry.asm|entry.z80> argument (and it must be last)`);
-    }
-    const ext = extname(state.entryFile).toLowerCase();
-    if (ext !== '.asm' && ext !== '.z80') {
-        fail(`Unsupported entry extension "${ext || '<none>'}" (expected .asm, .z80)`);
-    }
-    if (state.outputPath !== undefined) {
-        const wantExt = state.outputType === 'hex' ? '.hex' : '.bin';
-        const providedExt = extname(state.outputPath).toLowerCase();
-        if (providedExt !== wantExt) {
-            fail(`--output must end with "${wantExt}" when --type is "${state.outputType}"`);
-        }
-    }
-    const emitsRegisterCare = state.registerCare !== 'off' ||
-        state.emitRegisterReport ||
-        state.emitRegisterInterface ||
-        state.emitRegisterAnnotations ||
-        state.fixRegisterContracts ||
-        state.acceptRegisterOutputCandidates.length > 0 ||
-        state.registerCareInterfaces.length > 0;
-    if (state.outputType === 'hex' && !state.emitHex && !emitsRegisterCare) {
-        fail(`--type hex requires HEX output to be enabled`);
-    }
-    if (state.outputType === 'bin' && !state.emitBin && !emitsRegisterCare) {
-        fail(`--type bin requires BIN output to be enabled`);
-    }
+    validateEntryFile(state.entryFile);
+    validateOutputPath(state);
+    validateEnabledPrimaryOutput(state);
     return {
         entryFile: state.entryFile,
-        ...(state.outputPath ? { outputPath: state.outputPath } : {}),
+        ...cliOptionOutputPath(state),
         outputType: state.outputType,
-        ...(state.sourceRoot !== undefined ? { sourceRoot: state.sourceRoot } : {}),
+        ...cliOptionSourceRoot(state),
         emitBin: state.emitBin,
         emitHex: state.emitHex,
         emitD8m: state.emitD8m,
         emitAsm80: state.emitAsm80,
         caseStyle: state.caseStyle,
-        registerCare: state.registerCare,
+        registerContracts: state.registerContracts,
         emitRegisterReport: state.emitRegisterReport,
         emitRegisterInterface: state.emitRegisterInterface,
         emitRegisterAnnotations: state.emitRegisterAnnotations,
         fixRegisterContracts: state.fixRegisterContracts,
         acceptRegisterOutputCandidates: state.acceptRegisterOutputCandidates,
-        ...(state.registerCareProfile !== undefined
-            ? { registerCareProfile: state.registerCareProfile }
-            : {}),
-        registerCareInterfaces: state.registerCareInterfaces,
+        ...cliOptionRegisterContractsProfile(state),
+        registerContractsInterfaces: state.registerContractsInterfaces,
         includeDirs: state.includeDirs,
         directiveAliasFiles: state.directiveAliasFiles,
     };
 }
+function validateEntryFile(entryFile) {
+    if (!entryFile) {
+        fail(`Expected exactly one <entry.asm|entry.z80> argument (and it must be last)`);
+    }
+}
+function validateOutputPath(state) {
+    if (!state.entryFile)
+        return;
+    const ext = extname(state.entryFile).toLowerCase();
+    if (ext !== '.asm' && ext !== '.z80') {
+        fail(`Unsupported entry extension "${ext || '<none>'}" (expected .asm, .z80)`);
+    }
+    if (state.outputPath !== undefined) {
+        const wantExt = state.outputType === 'hex' ? '.hex' : '.bin';
+        const providedExt = extname(state.outputPath).toLowerCase();
+        if (providedExt !== wantExt) {
+            fail(`--output must end with "${wantExt}" when --type is "${state.outputType}"`);
+        }
+    }
+}
+function emitsRegisterContractsArtifact(state) {
+    return [
+        state.registerContracts !== 'off',
+        state.emitRegisterReport,
+        state.emitRegisterInterface,
+        state.emitRegisterAnnotations,
+        state.fixRegisterContracts,
+        state.acceptRegisterOutputCandidates.length > 0,
+        state.registerContractsInterfaces.length > 0,
+    ].some(Boolean);
+}
+function primaryOutputDisabled(state) {
+    return state.outputType === 'hex' ? !state.emitHex : !state.emitBin;
+}
+function primaryOutputName(state) {
+    return state.outputType === 'hex' ? 'HEX' : 'BIN';
+}
+function validateEnabledPrimaryOutput(state) {
+    if (primaryOutputDisabled(state) && !emitsRegisterContractsArtifact(state)) {
+        fail(`--type ${state.outputType} requires ${primaryOutputName(state)} output to be enabled`);
+    }
+}
+const VALUE_ARG_PARSERS = [
+    (arg, { argv, indexRef, state }) => parseOutputPathArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseOutputTypeArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseSourceRootArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseCaseStyleArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseDirectiveAliasFileArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseRegisterContractsArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseRegisterProfileArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseAcceptOutputArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseRegisterInterfaceArg(arg, argv, indexRef, state),
+    (arg, { argv, indexRef, state }) => parseIncludeArg(arg, argv, indexRef, state),
+];
+function parseBooleanFlag(arg, state) {
+    const action = BOOLEAN_FLAG_ACTIONS.find(({ flags }) => flags.includes(arg));
+    if (!action)
+        return false;
+    action.apply(state);
+    return true;
+}
+function parseValueArg(arg, context) {
+    return VALUE_ARG_PARSERS.some((parser) => parser(arg, context));
+}
+function parseEntryArg(arg, argv, indexRef, state) {
+    if (arg.startsWith('-')) {
+        fail(`Unknown option "${arg}"`);
+    }
+    if (state.entryFile !== undefined || indexRef.current !== argv.length - 1) {
+        fail(`Expected exactly one <entry.asm|entry.z80> argument (and it must be last)`);
+    }
+    state.entryFile = arg;
+}
 export function parseCliArgs(argv) {
     const state = createDefaultCliState();
     const indexRef = { current: 0 };
@@ -271,69 +355,11 @@ export function parseCliArgs(argv) {
         const fastPath = handleFastPath(arg);
         if (fastPath)
             return fastPath;
-        if (parseOutputPathArg(arg, argv, indexRef, state))
-            continue;
-        if (parseOutputTypeArg(arg, argv, indexRef, state))
-            continue;
-        if (arg === '--nobin') {
-            state.emitBin = false;
-            continue;
-        }
-        if (arg === '--nohex') {
-            state.emitHex = false;
-            continue;
-        }
-        if (arg === '--nod8m') {
-            state.emitD8m = false;
-            continue;
-        }
-        if (arg === '--asm80') {
-            state.emitAsm80 = true;
+        if (parseBooleanFlag(arg, state))
             continue;
-        }
-        if (arg === '--emit-register-report' || arg === '--reg-report') {
-            state.emitRegisterReport = true;
-            continue;
-        }
-        if (arg === '--emit-register-interface' || arg === '--reg-interface') {
-            state.emitRegisterInterface = true;
-            continue;
-        }
-        if (arg === '--fix') {
-            state.fixRegisterContracts = true;
-            state.emitRegisterAnnotations = true;
-            continue;
-        }
-        if (arg === '--contracts' || arg === '--annotate-register-contracts') {
-            state.emitRegisterAnnotations = true;
+        if (parseValueArg(arg, { argv, indexRef, state }))
             continue;
-        }
-        if (parseSourceRootArg(arg, argv, indexRef, state))
-            continue;
-        if (parseCaseStyleArg(arg, argv, indexRef, state))
-            continue;
-        if (parseDirectiveAliasFileArg(arg, argv, indexRef, state))
-            continue;
-        if (parseRegisterCareArg(arg, argv, indexRef, state))
-            continue;
-        if (parseRegisterProfileArg(arg, argv, indexRef, state))
-            continue;
-        if (parseAcceptOutputArg(arg, argv, indexRef, state))
-            continue;
-        if (parseRegisterInterfaceArg(arg, argv, indexRef, state))
-            continue;
-        if (parseIncludeArg(arg, argv, indexRef, state))
-            continue;
-        if (arg.startsWith('-')) {
-            fail(`Unknown option "${arg}"`);
-        }
-        if (state.entryFile !== undefined) {
-            fail(`Expected exactly one <entry.asm|entry.z80> argument (and it must be last)`);
-        }
-        if (indexRef.current !== argv.length - 1) {
-            fail(`Expected exactly one <entry.asm|entry.z80> argument (and it must be last)`);
-        }
-        state.entryFile = arg;
+        parseEntryArg(arg, argv, indexRef, state);
     }
     return finalizeCliOptions(state);
 }

package/dist/src/cli/run.js

@@ -1,7 +1,7 @@
 import { compile } from '../api-compile.js';
 import { formatDiagnostic } from '../diagnostics/format.js';
 import { cliUsage, parseCliArgs } from './parse-args.js';
-import { artifactBase, buildCompileOptions, compareDiagnosticsForCli, writeArtifacts } from './write-artifacts.js';
+import { artifactBase, buildCompileOptions, compareDiagnosticsForCli, writeArtifacts, } from './write-artifacts.js';
 export { parseCliArgs } from './parse-args.js';
 export async function runCli(argv) {
     try {
@@ -18,6 +18,9 @@ export async function runCli(argv) {
             }
         }
         if (sortedDiagnostics.some((diagnostic) => diagnostic.severity === 'error')) {
+            if (compileResult.artifacts.length > 0) {
+                await writeArtifacts(base, compileResult.artifacts, parsed.outputType);
+            }
             return 1;
         }
         const primaryPath = await writeArtifacts(base, compileResult.artifacts, parsed.outputType);

package/dist/src/cli/usage.d.ts

@@ -0,0 +1 @@
+export declare function cliUsage(): string;

package/dist/src/cli/usage.js

@@ -0,0 +1,33 @@
+export function cliUsage() {
+    return [
+        'azm [options] <entry.asm|entry.z80>',
+        '',
+        'Options:',
+        '  -o, --output <file>   Primary output path (must match --type extension)',
+        '  -t, --type <type>     Primary output type: hex|bin (default: hex)',
+        '      --nobin           Suppress .bin',
+        '      --nohex           Suppress .hex',
+        '      --nod8m           Suppress .d8.json',
+        '      --asm80           Emit lowered source (.z80)',
+        '      --register-contracts <m> Register contracts mode: off|audit|warn|error|strict',
+        '      --rc <m>           Register contracts mode alias for --register-contracts',
+        '      --reg-report       Emit register contracts report artifact',
+        '      --reg-interface     Emit inferred register contracts interface (.asmi)',
+        '      --contracts        Rewrite source with inferred register contracts',
+        '      --fix              Enable contract rewrite and conservative fixes',
+        '      --accept-out <x>   Accept register contracts output candidates',
+        '      --interface <file>  Load .asmi contract file',
+        '      --reg-profile <p>  Register contracts profile (currently mon3)',
+        '      --source-root <d> Normalize D8 source paths relative to this directory',
+        '      --case-style <m>  Case-style lint mode: off|upper|lower|consistent',
+        '      --aliases <file>  Load project directive alias JSON (repeatable)',
+        '  -I, --include <dir>   Add include search path (repeatable)',
+        '  -V, --version         Print version',
+        '  -h, --help            Show help',
+        '',
+        'Notes:',
+        '  - <entry.asm|entry.z80> must be the last argument (assembler-style).',
+        '  - Output artifacts are written using the primary output stem with standard suffixes.',
+        '',
+    ].join('\n');
+}

package/dist/src/cli/write-artifacts.js

@@ -1,5 +1,5 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, extname, resolve } from 'node:path';
+import { extname, resolve } from 'node:path';
+import { writeArtifactFiles } from './artifact-files.js';
 function normalizeDiagnosticPath(file) {
     const normalized = file.replace(/\\/g, '/');
     return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
@@ -38,97 +38,24 @@ export function artifactBase(entryFile, outputType, outputPath) {
     if (outputPath !== undefined) {
         const resolvedOutputPath = resolve(outputPath);
         const providedExt = extname(resolvedOutputPath);
-        return providedExt.length > 0 ? resolvedOutputPath.slice(0, -providedExt.length) : resolvedOutputPath;
+        return providedExt.length > 0
+            ? resolvedOutputPath.slice(0, -providedExt.length)
+            : resolvedOutputPath;
     }
     const resolvedEntry = resolve(entryFile);
     const entryExt = extname(resolvedEntry);
     return entryExt.length > 0 ? resolvedEntry.slice(0, -entryExt.length) : resolvedEntry;
 }
 export async function writeArtifacts(base, artifacts, outputType) {
-    const byKind = new Map();
-    for (const artifact of artifacts) {
-        byKind.set(artifact.kind, artifact);
-    }
-    const hexPath = `${base}.hex`;
-    const binPath = `${base}.bin`;
-    const d8mPath = `${base}.d8.json`;
-    const asm80Path = `${base}.z80`;
-    const registerCareReportPath = `${base}.regcare.txt`;
-    const registerCareInterfacePath = `${base}.asmi`;
-    const writes = [];
-    const ensureDir = async (path) => {
-        await mkdir(dirname(path), { recursive: true });
-    };
-    let primaryPath;
-    let registerCarePath;
-    const bin = byKind.get('bin');
-    if (bin && bin.kind === 'bin') {
-        writes.push((async () => {
-            await ensureDir(binPath);
-            await writeFile(binPath, Buffer.from(bin.bytes));
-        })());
-        if (outputType === 'bin') {
-            primaryPath = binPath;
-        }
-    }
-    const hex = byKind.get('hex');
-    if (hex && hex.kind === 'hex') {
-        writes.push((async () => {
-            await ensureDir(hexPath);
-            await writeFile(hexPath, hex.text, 'utf8');
-        })());
-        if (outputType === 'hex') {
-            primaryPath = hexPath;
-        }
-    }
-    const d8m = byKind.get('d8m');
-    if (d8m && d8m.kind === 'd8m') {
-        writes.push((async () => {
-            await ensureDir(d8mPath);
-            const text = JSON.stringify(d8m.json, null, 2);
-            await writeFile(d8mPath, `${text}\n`, 'utf8');
-        })());
-    }
-    const asm80 = byKind.get('asm80');
-    if (asm80 && asm80.kind === 'asm80') {
-        writes.push((async () => {
-            await ensureDir(asm80Path);
-            await writeFile(asm80Path, asm80.text, 'utf8');
-        })());
-    }
-    const registerCareReport = byKind.get('register-care-report');
-    if (registerCareReport && registerCareReport.kind === 'register-care-report') {
-        writes.push((async () => {
-            await ensureDir(registerCareReportPath);
-            await writeFile(registerCareReportPath, registerCareReport.text, 'utf8');
-        })());
-        registerCarePath = registerCareReportPath;
-    }
-    const registerCareInterface = byKind.get('register-care-interface');
-    if (registerCareInterface && registerCareInterface.kind === 'register-care-interface') {
-        writes.push((async () => {
-            await ensureDir(registerCareInterfacePath);
-            await writeFile(registerCareInterfacePath, registerCareInterface.text, 'utf8');
-        })());
-        registerCarePath ??= registerCareInterfacePath;
-    }
-    const registerCareAnnotations = byKind.get('register-care-annotations');
-    if (registerCareAnnotations && registerCareAnnotations.kind === 'register-care-annotations') {
-        for (const item of registerCareAnnotations.files) {
-            writes.push((async () => {
-                await ensureDir(item.path);
-                await writeFile(item.path, item.text, 'utf8');
-            })());
-            if (primaryPath === undefined) {
-                primaryPath = item.path;
-            }
-        }
-    }
-    await Promise.all(writes);
-    if (primaryPath !== undefined) {
-        return primaryPath;
-    }
-    return registerCarePath;
+    const result = await writeArtifactFiles(artifacts, {
+        hex: `${base}.hex`,
+        bin: `${base}.bin`,
+        d8m: `${base}.d8.json`,
+        asm80: `${base}.z80`,
+        registerContractsReport: `${base}.regcontracts.txt`,
+        registerContractsInterface: `${base}.asmi`,
+    }, outputType);
+    return result.primaryPath ?? result.registerContractsPath;
 }
 export function buildCompileOptions(parsed, base) {
     const hexPath = `${base}.hex`;
@@ -141,16 +68,16 @@ export function buildCompileOptions(parsed, base) {
         emitD8m: parsed.emitD8m,
         emitAsm80: parsed.emitAsm80,
         caseStyle: parsed.caseStyle,
-        registerCare: parsed.registerCare,
+        registerContracts: parsed.registerContracts,
         emitRegisterReport: parsed.emitRegisterReport,
         emitRegisterInterface: parsed.emitRegisterInterface,
         emitRegisterAnnotations: parsed.emitRegisterAnnotations,
         fixRegisterContracts: parsed.fixRegisterContracts,
         acceptRegisterOutputCandidates: parsed.acceptRegisterOutputCandidates,
-        ...(parsed.registerCareProfile !== undefined
-            ? { registerCareProfile: parsed.registerCareProfile }
+        ...(parsed.registerContractsProfile !== undefined
+            ? { registerContractsProfile: parsed.registerContractsProfile }
             : {}),
-        registerCareInterfaces: parsed.registerCareInterfaces,
+        registerContractsInterfaces: parsed.registerContractsInterfaces,
         ...(parsed.sourceRoot !== undefined ? { sourceRoot: parsed.sourceRoot } : {}),
         ...(parsed.sourceRoot !== undefined
             ? {