@jhlagado/azm 0.2.0 → 0.2.2

package/dist/src/syntax/parse-expression.js

@@ -36,7 +36,7 @@ export function parseExpression(text) {
         }
         if (token.kind === 'symbol') {
             const next = tokenList[index + 1];
-            if (token.text.toLowerCase() === 'sizeof' && next?.kind === 'left-paren') {
+            if (token.text === 'sizeof' && next?.kind === 'left-paren') {
                 index += 2;
                 const typeName = tokenList[index];
                 if (typeName?.kind !== 'symbol' || tokenList[index + 1]?.kind !== 'right-paren') {
@@ -45,7 +45,7 @@ export function parseExpression(text) {
                 index += 2;
                 return { kind: 'sizeof', typeExpr: { name: typeName.text } };
             }
-            if (token.text.toLowerCase() === 'offset' && next?.kind === 'left-paren') {
+            if (token.text === 'offset' && next?.kind === 'left-paren') {
                 index += 2;
                 const typeName = tokenList[index];
                 const comma = tokenList[index + 1];
@@ -133,12 +133,12 @@ function parseLayoutExpression(text) {
     if (layoutCast) {
         return layoutCast;
     }
-    const sizeof = /^sizeof\s*\((.*)\)$/i.exec(trimmed);
+    const sizeof = /^sizeof\s*\((.*)\)$/.exec(trimmed);
     if (sizeof) {
         const typeExpr = parseTypeExpr(sizeof[1] ?? '');
         return typeExpr ? { kind: 'sizeof', typeExpr } : undefined;
     }
-    const offset = /^offset\s*\((.*),(.*)\)$/i.exec(trimmed);
+    const offset = /^offset\s*\((.*),(.*)\)$/.exec(trimmed);
     if (offset) {
         const typeExpr = parseTypeExpr(offset[1] ?? '');
         const path = parseOffsetPath(offset[2] ?? '');
@@ -317,7 +317,7 @@ function tokenizeExpression(text) {
             index += 1;
             continue;
         }
-        if (char === "'" || char === '"') {
+        if (char === "'") {
             const quoted = scanQuotedByte(input, index, char);
             if (!quoted) {
                 return undefined;
@@ -326,7 +326,7 @@ function tokenizeExpression(text) {
             index = quoted.end;
             continue;
         }
-        const layoutTerm = scanLayoutTerm(input, index);
+        const layoutTerm = scanSpecialTerm(input, index);
         if (layoutTerm) {
             tokens.push({ kind: 'expression', expression: layoutTerm.expression });
             index = layoutTerm.end;
@@ -353,9 +353,34 @@ function tokenizeExpression(text) {
     }
     return tokens.length > 0 ? tokens : undefined;
 }
+function scanSpecialTerm(input, start) {
+    const byteFunction = scanByteFunction(input, start);
+    if (byteFunction) {
+        return byteFunction;
+    }
+    return scanLayoutTerm(input, start);
+}
+function scanByteFunction(input, start) {
+    const head = /^(LSB|MSB)\s*\(/.exec(input.slice(start));
+    if (!head) {
+        return undefined;
+    }
+    const name = head[1];
+    const open = input.indexOf('(', start + name.length);
+    if (open === -1 || input.slice(start + name.length, open).trim().length > 0) {
+        return undefined;
+    }
+    const close = findMatchingParen(input, open);
+    if (close === undefined) {
+        return undefined;
+    }
+    const expression = parseExpression(input.slice(open + 1, close));
+    return expression
+        ? { expression: { kind: 'byte-function', function: name, expression }, end: close + 1 }
+        : undefined;
+}
 function scanLayoutTerm(input, start) {
-    const lower = input.slice(start).toLowerCase();
-    if (lower.startsWith('sizeof')) {
+    if (input.slice(start).startsWith('sizeof')) {
         const open = input.indexOf('(', start + 'sizeof'.length);
         if (open === -1 || input.slice(start + 'sizeof'.length, open).trim().length > 0) {
             return undefined;
@@ -367,7 +392,7 @@ function scanLayoutTerm(input, start) {
         const expression = parseLayoutExpression(input.slice(start, close + 1));
         return expression ? { expression, end: close + 1 } : undefined;
     }
-    if (lower.startsWith('offset')) {
+    if (input.slice(start).startsWith('offset')) {
         const open = input.indexOf('(', start + 'offset'.length);
         if (open === -1 || input.slice(start + 'offset'.length, open).trim().length > 0) {
             return undefined;

package/dist/src/syntax/parse-line.js

@@ -1,38 +1,98 @@
-import { stripLineComment } from '../source/strip-line-comment.js';
+import { extractLineComment, stripLineComment } from '../source/strip-line-comment.js';
 import { normalizeDirectiveAlias } from './directive-aliases.js';
 import { parseExpression, parseTypeExpr } from './parse-expression.js';
 import { parseZ80Instruction } from '../z80/parse-instruction.js';
 export function parseLogicalLine(line, options = {}) {
     const text = normalizeDirectiveAlias(stripLineComment(line.text), options.directiveAliasPolicy).trim();
     if (text.length === 0) {
-        return { items: [], diagnostics: [] };
+        return commentOnlyLine(line);
     }
     const span = { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) };
     const labelWithStatement = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):\s*(.+)$/.exec(text);
     if (labelWithStatement) {
-        const labelName = normalizeEntryLabelName(labelWithStatement[1] ?? '');
+        const rawLabel = labelWithStatement[1] ?? '';
+        const labelName = normalizeEntryLabelName(rawLabel);
+        const isEntry = rawLabel.startsWith('@');
         const statementText = labelWithStatement[2] ?? '';
-        const equStatement = parseColonLabelEqu(line, labelName, statementText, span);
-        if (equStatement) {
-            return equStatement;
+        const invalidDeclaration = parseColonDeclarationError(labelName, statementText);
+        if (invalidDeclaration) {
+            return { items: [], diagnostics: [parseError(line, invalidDeclaration)] };
         }
         const parsedStatement = parseCanonicalStatement(line, statementText, span);
-        return {
-            items: [{ kind: 'label', name: labelName, span }, ...parsedStatement.items],
+        return withLineComment(line, {
+            items: [{ kind: 'label', name: labelName, ...(isEntry ? { isEntry: true } : {}), span }, ...parsedStatement.items],
             diagnostics: parsedStatement.diagnostics,
-        };
+        });
     }
     const labelOnly = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):$/.exec(text);
     if (labelOnly) {
-        return {
-            items: [{ kind: 'label', name: normalizeEntryLabelName(labelOnly[1] ?? ''), span }],
+        const rawLabel = labelOnly[1] ?? '';
+        return withLineComment(line, {
+            items: [
+                {
+                    kind: 'label',
+                    name: normalizeEntryLabelName(rawLabel),
+                    ...(rawLabel.startsWith('@') ? { isEntry: true } : {}),
+                    span,
+                },
+            ],
             diagnostics: [],
-        };
+        });
+    }
+    return withLineComment(line, parseCanonicalStatement(line, text, span));
+}
+function commentOnlyLine(line) {
+    const comment = extractLineComment(line.text);
+    if (!comment) {
+        return { items: [], diagnostics: [] };
+    }
+    return {
+        items: [
+            {
+                kind: 'comment',
+                text: comment,
+                origin: 'user',
+                span: {
+                    sourceName: line.sourceName,
+                    line: line.line,
+                    column: firstColumn(line.text),
+                },
+            },
+        ],
+        diagnostics: [],
+    };
+}
+function withLineComment(line, result) {
+    const comment = extractLineComment(line.text);
+    if (!comment) {
+        return result;
     }
-    return parseCanonicalStatement(line, text, span);
+    return {
+        items: [
+            ...result.items,
+            {
+                kind: 'comment',
+                text: comment,
+                origin: 'user',
+                span: {
+                    sourceName: line.sourceName,
+                    line: line.line,
+                    column: firstColumn(line.text),
+                },
+            },
+        ],
+        diagnostics: result.diagnostics,
+    };
 }
 function parseEquItem(line, name, expressionText, span) {
     const stringValue = parseWholeQuotedString(expressionText.trim());
+    const quotePolicyError = parseEquQuotePolicyError(expressionText.trim());
+    if (quotePolicyError) {
+        return {
+            items: [],
+            diagnostics: [parseError(line, quotePolicyError)],
+        };
+    }
     const expression = stringValue !== undefined && stringValue.length > 1
         ? { kind: 'number', value: 0 }
         : parseExpression(expressionText);
@@ -55,19 +115,12 @@ function parseEquItem(line, name, expressionText, span) {
         diagnostics: [],
     };
 }
-function parseColonLabelEqu(line, name, text, span) {
-    const equ = /^\.equ\s+(.+)$/i.exec(text);
-    if (!equ) {
-        return undefined;
-    }
-    return parseEquItem(line, name, equ[1] ?? '', span);
-}
 function parseCanonicalStatement(line, text, span) {
-    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/i.exec(text);
+    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/.exec(text);
     if (equ) {
         return parseEquItem(line, equ[1] ?? '', equ[2] ?? '', span);
     }
-    const org = /^\.org\s+(.+)$/i.exec(text);
+    const org = /^\.org\s+(.+)$/.exec(text);
     if (org) {
         const expressionText = org[1] ?? '';
         const expression = parseExpression(expressionText);
@@ -79,32 +132,18 @@ function parseCanonicalStatement(line, text, span) {
         }
         return { items: [{ kind: 'org', expression, span }], diagnostics: [] };
     }
-    const enumDecl = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/i.exec(text);
+    const enumDecl = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/.exec(text);
     if (enumDecl) {
-        const name = enumDecl[1] ?? '';
-        const membersText = enumDecl[2] ?? '';
-        const rawMembers = membersText.split(',').map((member) => member.trim());
-        if (membersText.trim().length === 0 || rawMembers.some((member) => member.length === 0)) {
-            return {
-                items: [],
-                diagnostics: [parseError(line, `invalid enum member list`)],
-            };
-        }
-        const members = [];
-        const diagnostics = [];
-        for (const member of rawMembers) {
-            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(member)) {
-                diagnostics.push(parseError(line, `Invalid enum member name "${member}": expected <identifier>.`));
-                continue;
-            }
-            members.push(member);
-        }
-        if (diagnostics.length > 0) {
-            return { items: [], diagnostics };
-        }
-        return { items: [{ kind: 'enum', name, members, span }], diagnostics: [] };
+        return {
+            items: [],
+            diagnostics: [parseError(line, `Use "${enumDecl[1] ?? ''} .enum ..." for enums.`)],
+        };
     }
-    const data = /^(\.db|\.dw)\s+(.+)$/i.exec(text);
+    const nameLeftEnum = /^([A-Za-z_][A-Za-z0-9_]*)\s+\.enum\s+(.+)$/.exec(text);
+    if (nameLeftEnum) {
+        return parseEnumItem(line, nameLeftEnum[1] ?? '', nameLeftEnum[2] ?? '', span);
+    }
+    const data = /^(\.db|\.dw)\s+(.+)$/.exec(text);
     if (data) {
         const directive = (data[1] ?? '').slice(1).toLowerCase();
         const valueText = data[2] ?? '';
@@ -113,9 +152,10 @@ function parseCanonicalStatement(line, text, span) {
             ? parts.map(parseDataValue).filter((value) => value !== undefined)
             : parts.map(parseExpression).filter((value) => value !== undefined);
         if (values.length !== parts.length) {
+            const quotePolicyError = parts.map(parseDataQuotePolicyError).find(Boolean);
             return {
                 items: [],
-                diagnostics: [parseError(line, `invalid .${directive} value list`)],
+                diagnostics: [parseError(line, quotePolicyError ?? `invalid .${directive} value list`)],
             };
         }
         return {
@@ -125,7 +165,7 @@ function parseCanonicalStatement(line, text, span) {
             diagnostics: [],
         };
     }
-    const ds = /^\.ds\s+(.+)$/i.exec(text);
+    const ds = /^\.ds\s+(.+)$/.exec(text);
     if (ds) {
         const parts = splitValueList(ds[1] ?? '');
         if (parts.length < 1 || parts.length > 2) {
@@ -155,7 +195,7 @@ function parseCanonicalStatement(line, text, span) {
             diagnostics: [],
         };
     }
-    const align = /^\.align\s+(.+)$/i.exec(text);
+    const align = /^\.align\s+(.+)$/.exec(text);
     if (align) {
         const expressionText = align[1] ?? '';
         const alignment = parseExpression(expressionText);
@@ -167,10 +207,10 @@ function parseCanonicalStatement(line, text, span) {
         }
         return { items: [{ kind: 'align', alignment, span }], diagnostics: [] };
     }
-    if (/^\.end\s*$/i.test(text)) {
+    if (/^\.end\s*$/.test(text)) {
         return { items: [{ kind: 'end', span }], diagnostics: [] };
     }
-    const rangeControl = /^(\.binfrom|\.binto)\s+(.+)$/i.exec(text);
+    const rangeControl = /^(\.binfrom|\.binto)\s+(.+)$/.exec(text);
     if (rangeControl) {
         const kind = (rangeControl[1] ?? '').slice(1).toLowerCase();
         const expressionText = rangeControl[2] ?? '';
@@ -183,7 +223,7 @@ function parseCanonicalStatement(line, text, span) {
         }
         return { items: [{ kind, expression, span }], diagnostics: [] };
     }
-    const stringData = /^(\.cstr|\.pstr|\.istr)\s+(.+)$/i.exec(text);
+    const stringData = /^(\.cstr|\.pstr|\.istr)\s+(.+)$/.exec(text);
     if (stringData) {
         const directive = (stringData[1] ?? '').slice(1).toLowerCase();
         const valueText = stringData[2] ?? '';
@@ -191,7 +231,7 @@ function parseCanonicalStatement(line, text, span) {
         if (value === undefined) {
             return {
                 items: [],
-                diagnostics: [parseError(line, `.${directive} expects one quoted string`)],
+                diagnostics: [parseError(line, `.${directive} expects one double-quoted string`)],
             };
         }
         return { items: [{ kind: 'string-data', directive, value, span }], diagnostics: [] };
@@ -214,6 +254,46 @@ function parseCanonicalStatement(line, text, span) {
     }
     return { items: [], diagnostics: [parseError(line, `unsupported source line: ${text}`)] };
 }
+function parseColonDeclarationError(name, statementText) {
+    if (/^\.equ\b/.test(statementText)) {
+        return `Use "${name} .equ ..." for constants; colon labels mark addresses.`;
+    }
+    if (/^\.enum\b/.test(statementText)) {
+        return `Use "${name} .enum ..." for enums; colon labels mark addresses.`;
+    }
+    if (/^\.typealias\b/.test(statementText)) {
+        return `Use "${name} .typealias ..." for type aliases; colon labels mark addresses.`;
+    }
+    if (/^\.type\b/.test(statementText)) {
+        return `Use "${name} .type" for layouts; colon labels mark addresses.`;
+    }
+    if (/^\.union\b/.test(statementText)) {
+        return `Use "${name} .union" for layouts; colon labels mark addresses.`;
+    }
+    return undefined;
+}
+function parseEnumItem(line, name, membersText, span) {
+    const rawMembers = membersText.split(',').map((member) => member.trim());
+    if (membersText.trim().length === 0 || rawMembers.some((member) => member.length === 0)) {
+        return {
+            items: [],
+            diagnostics: [parseError(line, `invalid enum member list`)],
+        };
+    }
+    const members = [];
+    const diagnostics = [];
+    for (const member of rawMembers) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(member)) {
+            diagnostics.push(parseError(line, `Invalid enum member name "${member}": expected <identifier>.`));
+            continue;
+        }
+        members.push(member);
+    }
+    if (diagnostics.length > 0) {
+        return { items: [], diagnostics };
+    }
+    return { items: [{ kind: 'enum', name, members, span }], diagnostics: [] };
+}
 function parseTypeSizeExpression(text) {
     const typeExpr = parseTypeExpr(text);
     return typeExpr ? { kind: 'type-size', typeExpr } : undefined;
@@ -289,7 +369,7 @@ function parseDataValue(text) {
 function parseWholeQuotedString(text) {
     const input = text.trim();
     const quote = input[0];
-    if ((quote !== '"' && quote !== "'") || input[input.length - 1] !== quote) {
+    if (quote !== '"' || input[input.length - 1] !== quote) {
         return undefined;
     }
     let value = '';
@@ -310,6 +390,22 @@ function parseWholeQuotedString(text) {
     }
     return value;
 }
+function parseEquQuotePolicyError(text) {
+    if (!text.startsWith('"') || !text.endsWith('"')) {
+        return undefined;
+    }
+    const stringValue = parseWholeQuotedString(text);
+    return stringValue !== undefined && stringValue.length === 1
+        ? 'double-quoted values are strings; use single quotes for character literals'
+        : undefined;
+}
+function parseDataQuotePolicyError(text) {
+    const input = text.trim();
+    if (!input.startsWith("'") || !input.endsWith("'")) {
+        return undefined;
+    }
+    return 'single quotes are for one character literal; use double quotes for strings';
+}
 function normalizeEntryLabelName(raw) {
     return raw.startsWith('@') ? raw.slice(1) : raw;
 }

package/dist/src/tooling/case-style.js

@@ -68,6 +68,9 @@ function isPotentialOpInvocationLine(text) {
         return false;
     if (/^[A-Za-z_][A-Za-z0-9_]*\s+\.?equ\b/i.test(text))
         return false;
+    if (/^[A-Za-z_][A-Za-z0-9_]*\s+\.(?:enum|type|union|typealias|field|byte|word|addr)\b/.test(text)) {
+        return false;
+    }
     if (/^(?:op|end|enum|type|union|field|byte|word|addr)\b/i.test(text))
         return false;
     if (/^(?:org|equ|db|dw|ds|align|include|binfrom|binto|cstr|pstr|istr)\b/i.test(text)) {

package/docs/reference/cli.md

@@ -55,7 +55,6 @@ same base path.
 | -------------- | -------------------------------- |
 | `.hex`         | Intel HEX output                 |
 | `.bin`         | flat binary output               |
-| `.lst`         | listing with bytes and symbols   |
 | `.d8.json`     | Debug80 map                      |
 | `.z80`         | lowered assembler source         |
 | `.regcare.txt` | register-care report             |
@@ -64,7 +63,7 @@ same base path.
 Disable standard artifacts when they are not needed:
 
 ```sh
-azm --nolist --nod8m program.asm
+azm --nod8m program.asm
 azm --nobin --nohex --reg-report --rc audit program.asm
 ```
 
@@ -74,13 +73,12 @@ azm --nobin --nohex --reg-report --rc audit program.asm
 | --------------------------------------------- | -------------------------------------------------------------------- |
 | `-o, --output <file>`                         | Primary output path. The extension must match `--type`.              |
 | `-t, --type <hex\|bin>`                       | Primary output type. Default: `hex`.                                 |
-| `-n, --nolist`                                | Do not write `.lst`.                                                 |
 | `--nobin`                                     | Do not write `.bin`.                                                 |
 | `--nohex`                                     | Do not write `.hex`.                                                 |
 | `--nod8m`                                     | Do not write `.d8.json`.                                             |
 | `--asm80`                                     | Write lowered assembler source as `.z80`.                            |
 | `--source-root <dir>`                         | Emit project-relative source paths in `.d8.json`.                    |
-| `--case-style <mode>`                         | Lint opcode/register case: `off`, `upper`, `lower`, or `consistent`. |
+| `--case-style <mode>`                         | Lint mnemonic/register/op-head case: `off`, `upper`, `lower`, or `consistent`. |
 | `--rc, --register-care <mode>`                | Register-care mode: `off`, `audit`, `warn`, `error`, or `strict`.    |
 | `--reg-report, --emit-register-report`        | Write `.regcare.txt`.                                                |
 | `--reg-interface, --emit-register-interface`  | Write inferred `.asmi` interface.                                    |
@@ -96,6 +94,10 @@ azm --nobin --nohex --reg-report --rc audit program.asm
 
 ## Debug80 Maps
 
+`--case-style` is a source-style lint only. It checks instruction mnemonics,
+register names, and visible `op` heads/bodies. It does not rename labels,
+constants, directives, or compile-time functions.
+
 The `.d8.json` artifact records AZM as the generator, the package version, and
 the input/output paths used for the map. When `--source-root` is supplied, file
 keys and generator input paths are written relative to that directory with `/`

package/docs/reference/tooling-api.md

@@ -60,7 +60,6 @@ const result = await compile(
     includeDirs: ['/abs/path/to/includes'],
     sourceRoot: '/abs/path/to/project',
     d8mInputs: {
-      listing: '/abs/path/to/project/build/main.lst',
       hex: '/abs/path/to/project/build/main.hex',
       bin: '/abs/path/to/project/build/main.bin',
     },
@@ -68,7 +67,6 @@ const result = await compile(
     emitBin: true,
     emitHex: true,
     emitD8m: true,
-    emitListing: true,
     registerCare: 'audit',
     registerCareInterfaces: ['/abs/path/to/mon3.asmi'],
   },
@@ -89,7 +87,9 @@ The integration contract is:
 - `compile()` returns artifacts in memory; the CLI is only responsible for
   writing those artifacts to disk
 - Debug80 should consume the `d8m` artifact for source/address metadata and the
-  `bin` or `hex` artifact for loadable bytes
+  `bin` artifact for loadable bytes (hex is acceptable when bin is not emitted)
+- Do not rely on lowered `.z80` for Debug80 integration until asm80 coverage is
+  complete; use **bin + d8m** as the supported debugger path
 - pass `sourceRoot` so D8 file keys are stable project-relative source paths
   rather than basename-only paths
 - pass `d8mInputs` when Debug80 knows the intended artifact paths; AZM records
@@ -123,7 +123,6 @@ The top-level map contains:
     version: '0.1.1',
     inputs: {
       entry: 'src/pacmo/pacmo.z80',
-      listing: 'build/pacmo.lst',
       hex: 'build/pacmo.hex',
       bin: 'build/pacmo.bin',
     },
@@ -252,6 +251,12 @@ const result = await compile(
 );
 ```
 
+**`emitAsm80` caveat:** Lowered `.z80` emission is gated but not universal.
+Unsupported instructions or operand forms throw `UnsupportedAsm80LoweringError`,
+surfaced as `AZMN_ASM80`. When assembly already succeeded, `compile()` still
+returns bin/hex/d8 artifacts alongside the asm80 error. Run
+`npm run check:asm80-coverage` on your sources before relying on lowered output.
+
 The compiler accepts flat `.asm` / `.z80` source, retained AZM assembler
 features, and the same output writers used by the CLI. External register-care
 interfaces are `.asmi` metadata files, not compile entry files.
@@ -270,20 +275,19 @@ generated frames are outside this API contract for AZM source.
 The public tooling surface includes:
 
 - `Diagnostic`, `DiagnosticIds`, severity/id types
-- `SourcePosition`, `SourceSpan`
-- `ProgramNode`, `SourceFileNode`, `SourceItemNode`
 - `LoadedProgram`
-- `CompileEnv`
+- `AnalyzeProgramResult`, `LoadProgramResult`
 - `RegisterCareCandidateDiagnostic`, `RegisterCareCodeAction`, `RegisterCareOutputCandidate`
 
-In v1, the AST exported from `src/frontend/ast.ts` is part of the public contract. Additive fields are minor-version changes; breaking shape changes are major-version changes.
+The public tooling contract is the package export surface, not deep internal
+paths. Do not document retired internal modules as public API.
 
 ## Syntax Highlighting Example
 
 Syntax colouring is an example consumer of the tooling API:
 
 1. Call `loadProgram()` with the file path and optional unsaved buffer text.
-2. Walk `ProgramNode` and inspect `node.kind` plus `node.span`.
+2. Walk `loadedProgram.program.files[0].items` and inspect each item's `kind` and `span`.
 3. Map those spans to TextMate scopes or semantic token kinds in the editor.
 4. Fall back to regex/TextMate-only colouring if parsing fails or the editor needs a cheaper fast path.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhlagado/azm",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "AZM assembler for the Z80 family (Node.js CLI)",
   "license": "GPL-3.0-only",
   "engines": {
@@ -33,7 +33,6 @@
   },
   "files": [
     "dist/src",
-    "dist/legacy-root-azm",
     "docs/reference/cli.md",
     "docs/reference/tooling-api.md"
   ],
@@ -72,7 +71,9 @@
     "test:coverage": "vitest run --coverage",
     "test:ci:coverage-core": "node scripts/dev/run-coverage-core.mjs",
     "test:ci:slow-reliability": "vitest run --no-file-parallelism --maxWorkers=1 --minWorkers=1 --testTimeout=20000 --hookTimeout=300000 test/cli test/cli_*.test.ts",
+    "test:ci:asm80-parity": "node scripts/ci/run-asm80-parity.mjs",
     "check:fixture-coverage": "node scripts/dev/check-fixture-coverage.mjs",
+    "check:asm80-coverage": "node scripts/dev/check-asm80-lowering-coverage.mjs",
     "test:azm:alpha": "node scripts/dev/run-azm-alpha-guardrails.mjs",
     "test:azm:corpus": "node scripts/dev/run-azm-corpus-guardrails.mjs",
     "test:package": "npm run build && node scripts/dev/smoke-npm-package.mjs",
@@ -84,7 +85,7 @@
     "next:typecheck": "tsc -p tsconfig.json --noEmit",
     "next:test": "vitest run --config vitest.config.ts",
     "next:check": "npm run next:typecheck && npm run next:test",
-    "next:guardrails:core": "npm run next:check && npm run next:diff-current:all",
+    "next:guardrails:core": "npm run next:check && npm run check:asm80-coverage && npm run test:ci:asm80-parity",
     "next:guardrails:package": "npm run test:package || npm run next:guardrails:package:local",
     "next:guardrails:package:local": "npm run build && vitest run -c vitest.config.ts test/integration/stage-16-package-smoke-local.test.ts && vitest run test/public_api_surface.test.ts",
     "next:guardrails:quality": "npm run lint && npm run check:source-file-sizes && node scripts/check-source-file-sizes.mjs",
@@ -93,9 +94,6 @@
     "format:check": "prettier -c .",
     "check:source-file-sizes": "node scripts/check-source-file-sizes.mjs",
     "check:source-file-sizes:enforce": "node scripts/check-source-file-sizes.mjs --enforce-hard-cap",
-    "next:diff-current": "node scripts/diff-against-current.mjs --fixtures-dir test/differential/fixtures --skip-unsupported",
-    "next:diff-current:root": "node scripts/diff-against-current.mjs --fixtures-dir test/fixtures --skip-unsupported",
-    "next:diff-current:all": "npm run next:diff-current && npm run next:diff-current:root",
     "prepack": "npm run build",
     "prepublishOnly": "npm run build",
     "azm": "npm run build && node dist/src/cli.js"

package/dist/legacy-root-azm/src/analysis.d.ts

@@ -1,11 +0,0 @@
-import type { Diagnostic } from './diagnosticTypes.js';
-import type { LoadedProgram } from './sourceLoader.js';
-import type { CompilerOptions } from './pipeline.js';
-import { type CompileEnv } from './semantics/env.js';
-export interface AnalyzeProgramOptions extends Pick<CompilerOptions, 'caseStyle' | 'requireMain'> {
-}
-export interface AnalyzeProgramResult {
-    diagnostics: Diagnostic[];
-    env?: CompileEnv;
-}
-export declare function analyzeLoadedProgram(loadedProgram: LoadedProgram, options?: AnalyzeProgramOptions): AnalyzeProgramResult;

package/dist/legacy-root-azm/src/analysis.js

@@ -1,41 +0,0 @@
-import { hasErrors } from './compileShared.js';
-import { DiagnosticIds } from './diagnosticTypes.js';
-import { lintCaseStyle } from './lintCaseStyle.js';
-import { buildEnv } from './semantics/env.js';
-function hasMainEntryLabel(program) {
-    return program.files.some((sourceFile) => sourceFile.items.some((item) => item.kind === 'AsmLabel' && item.name.toLowerCase() === 'main'));
-}
-export function analyzeLoadedProgram(loadedProgram, options = {}) {
-    const diagnostics = [];
-    const { program, sourceTexts } = loadedProgram;
-    const hasProgramItems = program.files.some((sourceFile) => sourceFile.items.length > 0);
-    if (!hasProgramItems) {
-        diagnostics.push({
-            id: DiagnosticIds.SemanticsError,
-            severity: 'error',
-            message: 'Program contains no declarations or instruction streams.',
-            file: program.entryFile,
-            ...(program.span?.start
-                ? { line: program.span.start.line, column: program.span.start.column }
-                : {}),
-        });
-        return { diagnostics };
-    }
-    if ((options.requireMain ?? false) && !hasMainEntryLabel(program)) {
-        diagnostics.push({
-            id: DiagnosticIds.SemanticsError,
-            severity: 'error',
-            message: 'Program must define a "main" entry label.',
-            file: program.entryFile,
-            ...(program.span?.start
-                ? { line: program.span.start.line, column: program.span.start.column }
-                : {}),
-        });
-        return { diagnostics };
-    }
-    lintCaseStyle(program, sourceTexts, options.caseStyle ?? 'off', diagnostics);
-    const env = buildEnv(program, diagnostics);
-    if (hasErrors(diagnostics))
-        return { diagnostics };
-    return { diagnostics, env };
-}

package/dist/legacy-root-azm/src/compile.d.ts

@@ -1,10 +0,0 @@
-import type { CompileFn } from './pipeline.js';
-/**
- * Compile an AZM/ASM80-family program starting from an entry file.
- *
- * - Expands textual includes transitively with deterministic cycle checks.
- * - Runs parse → semantics → lowering → format writers.
- * - Produces artifacts in-memory via `deps.formats`.
- * - Defaults to emitting BIN + HEX + D8M unless an emit flag is explicitly provided.
- */
-export declare const compile: CompileFn;