@jhlagado/azm 0.2.1 → 0.2.2

package/README.md

@@ -2,7 +2,7 @@
 
 AZM is the Z80 assembler used by the Debug80 toolchain. It assembles plain
 `.asm` and `.z80` source into machine-code artifacts for hardware, emulators,
-and Debug80: Intel HEX, flat binary, listings, Debug80 maps, and optional
+and Debug80: Intel HEX, flat binary, Debug80 maps, and optional
 ASM80-compatible lowered source.
 
 The user manual is the AZM book in the Debug80 documentation site:
@@ -22,19 +22,28 @@ AZM keeps the parts of the original assembler that matter for real Z80 work:
 - global labels, with `@NAME:` labels marking routine entries for register-care
   analysis
 - canonical dotted directives such as `.org`, `.equ`, `.db`, `.dw`, and `.ds`
-- compatibility spelling for common undotted directive heads such as `ORG`,
-  `EQU`, `DB`, `DW`, and `DS`
+- exact compatibility spelling for common undotted directive heads such as
+  `ORG`, `EQU`, `DB`, `DW`, and `DS`
+- lowercase, case-sensitive canonical dotted directives; compatibility spellings
+  are handled as directive aliases, not as canonical AZM style
+- colon labels are address labels only; declarations use name-left forms such as
+  `Name .equ`, `Name .enum`, `Name .type`, `Name .union`, and
+  `Name .typealias`
 - textual `.include`
+- conditional source inclusion with lowercase `.if`, `.else`, and `.endif`
 - register-care contracts, AZMDoc comments, and `.asmi` external interfaces
 - `op` definitions for structured inline instruction idioms
 - enums and qualified enum constants
-- `.type` / `.union` layout metadata
+- `.type` / `.union` layout metadata and `Name .typealias TypeExpr` layout aliases
 - compile-time layout constants such as `sizeof(...)`, `offset(...)`, scalar
-  layout sizes, and constant-only layout casts
+  layout sizes, constant-only layout casts, `LSB(...)`, and `MSB(...)`
+- case-sensitive AZM function names with documented spelling, such as
+  `sizeof(...)`, `offset(...)`, `LSB(...)`, and `MSB(...)`
 - data directives including `.db`, `.dw`, `.ds`, `.cstr`, `.pstr`, and `.istr`
+- single quotes are character literals; double quotes are strings
 
 AZM does not implement text macros, local labels, modules/imports, `func`,
-formal arguments, generated stack frames, structured control flow, typed
+formal arguments, generated stack frames, runtime structured control flow, typed
 assignment lowering, hidden typed load/store lowering, or named section blocks.
 Those features belong to older high-level ZAX-era code paths, not current AZM
 source.
@@ -96,14 +105,13 @@ using the same base path.
 | -------------- | --------------------------------------------- |
 | `.hex`         | Intel HEX                                     |
 | `.bin`         | flat binary                                   |
-| `.lst`         | listing with bytes and symbols                |
 | `.d8.json`     | Debug80 map                                   |
 | `.z80`         | ASM80-compatible lowered source when enabled  |
 | `.regcare.txt` | register-care report when enabled             |
 | `.asmi`        | inferred register-care interface when enabled |
 
 The `.z80` output is a generated compatibility artifact for ASM80-style
-workflows and comparison tooling. BIN, HEX, listings, Debug80 maps, and
+workflows and comparison tooling. BIN, HEX, Debug80 maps, and
 register-care reports are the normal production outputs.
 
 ## Small Example
@@ -142,7 +150,6 @@ const result = await compile(
     sourceRoot: '/abs/path/to/project',
     d8mInputs: {
       hex: '/abs/path/to/project/build/main.hex',
-      listing: '/abs/path/to/project/build/main.lst',
     },
   },
   { formats: defaultFormatWriters },

package/dist/src/api-compile.d.ts

@@ -20,14 +20,12 @@ export interface CompileNextFunctionOptions {
     readonly outputType?: 'bin' | 'hex';
     readonly sourceRoot?: string;
     readonly d8mInputs?: {
-        readonly listing?: string;
         readonly hex?: string;
         readonly bin?: string;
     };
     readonly emitBin?: boolean;
     readonly emitHex?: boolean;
     readonly emitD8m?: boolean;
-    readonly emitListing?: boolean;
     readonly emitAsm80?: boolean;
     readonly registerCare?: RegisterCareMode;
     readonly emitRegisterReport?: boolean;

package/dist/src/api-compile.js

@@ -152,7 +152,6 @@ export async function compile(entryFile, options = {}, deps = { formats: default
             packageVersion: await readPackageVersion(),
             inputs: {
                 entry: normalizedEntry,
-                ...(options.d8mInputs?.listing !== undefined ? { listing: options.d8mInputs.listing } : {}),
                 ...(options.d8mInputs?.hex !== undefined ? { hex: options.d8mInputs.hex } : {}),
                 ...(options.d8mInputs?.bin !== undefined ? { bin: options.d8mInputs.bin } : {}),
             },
@@ -163,11 +162,6 @@ export async function compile(entryFile, options = {}, deps = { formats: default
         };
         artifacts.push(deps.formats.writeD8m(sidecarMap, symbols, d8mOpts));
     }
-    if (emit.emitListing) {
-        if (deps.formats.writeListing !== undefined) {
-            artifacts.push(deps.formats.writeListing(sidecarMap, symbols));
-        }
-    }
     if (emit.emitAsm80) {
         if (deps.formats.writeAsm80 !== undefined) {
             try {
@@ -196,9 +190,8 @@ function compileArtifactDefaults(options) {
     const emitBin = anyPrimary ? (options.emitBin ?? false) : true;
     const emitHex = anyPrimary ? (options.emitHex ?? false) : true;
     const emitD8m = anyPrimary ? (options.emitD8m ?? false) : true;
-    const emitListing = options.emitListing ?? true;
     const emitAsm80 = options.emitAsm80 ?? false;
-    return { emitBin, emitHex, emitD8m, emitListing, emitAsm80 };
+    return { emitBin, emitHex, emitD8m, emitAsm80 };
 }
 function assembledImageToMap(bytes, origin, sourceSegments = []) {
     const map = new Map();

package/dist/src/assembly/address-planning.js

@@ -52,6 +52,9 @@ function buildAddressStateOnce(items, diagnostics, previous, reportUnknown) {
             case 'type':
                 defineLayout(layouts, labels, equates, enumNamesLower, item.name, item.layoutKind, item.fields, item.span, diagnostics);
                 break;
+            case 'type-alias':
+                defineTypeAlias(layouts, labels, equates, enumNamesLower, item.name, item.typeExpr, item.span, diagnostics);
+                break;
             case 'equ':
                 defineEquate(equates, labels, layouts, enumNames, enumNamesLower, item.name, item.expression, item.span, placementAddress(placement), diagnostics, item.stringValue);
                 break;
@@ -156,7 +159,11 @@ function addressStateSignature(state) {
     return JSON.stringify({
         labels: state.labels,
         equates: [...state.equates].map(([name, record]) => [name, record.currentLocation]),
-        layouts: [...state.layouts].map(([name, record]) => [name, record.kind, record.fields]),
+        layouts: [...state.layouts].map(([name, record]) => [
+            name,
+            record.kind,
+            record.kind === 'alias' ? record.typeExpr : record.fields,
+        ]),
         origin: state.origin,
     });
 }
@@ -180,6 +187,17 @@ function defineLayout(layouts, labels, equates, enumNamesLower, name, layoutKind
     }
     layouts.set(name, { kind: layoutKind, fields, span });
 }
+function defineTypeAlias(layouts, labels, equates, enumNamesLower, name, typeExpr, span, diagnostics) {
+    const lowerName = name.toLowerCase();
+    if (hasCaseInsensitiveMapKey(layouts, lowerName) ||
+        hasCaseInsensitiveKey(labels, lowerName) ||
+        hasCaseInsensitiveMapKey(equates, lowerName) ||
+        enumNamesLower.has(lowerName)) {
+        diagnostics.push(diagnostic(span, `duplicate type name: ${name}`));
+        return;
+    }
+    layouts.set(name, { kind: 'alias', typeExpr, span });
+}
 function defineLabel(labels, equates, layouts, enumNamesLower, name, address, span, diagnostics) {
     if (labels[name] !== undefined ||
         equates.has(name) ||

package/dist/src/cli/parse-args.d.ts

@@ -11,7 +11,6 @@ export type CliOptions = {
     emitBin: boolean;
     emitHex: boolean;
     emitD8m: boolean;
-    emitListing: boolean;
     emitAsm80: boolean;
     caseStyle: CaseStyleMode;
     registerCare: RegisterCareMode;

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

@@ -7,7 +7,6 @@ export function cliUsage() {
         'Options:',
         '  -o, --output <file>   Primary output path (must match --type extension)',
         '  -t, --type <type>     Primary output type: hex|bin (default: hex)',
-        '  -n, --nolist          Suppress .lst',
         '      --nobin           Suppress .bin',
         '      --nohex           Suppress .hex',
         '      --nod8m           Suppress .d8.json',
@@ -44,7 +43,6 @@ function createDefaultCliState() {
         emitBin: true,
         emitHex: true,
         emitD8m: true,
-        emitListing: true,
         emitAsm80: false,
         caseStyle: 'off',
         registerCare: 'off',
@@ -249,7 +247,6 @@ function finalizeCliOptions(state) {
         emitBin: state.emitBin,
         emitHex: state.emitHex,
         emitD8m: state.emitD8m,
-        emitListing: state.emitListing,
         emitAsm80: state.emitAsm80,
         caseStyle: state.caseStyle,
         registerCare: state.registerCare,
@@ -278,10 +275,6 @@ export function parseCliArgs(argv) {
             continue;
         if (parseOutputTypeArg(arg, argv, indexRef, state))
             continue;
-        if (arg === '-n' || arg === '--nolist') {
-            state.emitListing = false;
-            continue;
-        }
         if (arg === '--nobin') {
             state.emitBin = false;
             continue;

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

@@ -52,7 +52,6 @@ export async function writeArtifacts(base, artifacts, outputType) {
     const hexPath = `${base}.hex`;
     const binPath = `${base}.bin`;
     const d8mPath = `${base}.d8.json`;
-    const lstPath = `${base}.lst`;
     const asm80Path = `${base}.z80`;
     const registerCareReportPath = `${base}.regcare.txt`;
     const registerCareInterfacePath = `${base}.asmi`;
@@ -90,13 +89,6 @@ export async function writeArtifacts(base, artifacts, outputType) {
             await writeFile(d8mPath, `${text}\n`, 'utf8');
         })());
     }
-    const lst = byKind.get('lst');
-    if (lst && lst.kind === 'lst') {
-        writes.push((async () => {
-            await ensureDir(lstPath);
-            await writeFile(lstPath, lst.text, 'utf8');
-        })());
-    }
     const asm80 = byKind.get('asm80');
     if (asm80 && asm80.kind === 'asm80') {
         writes.push((async () => {
@@ -141,14 +133,12 @@ export async function writeArtifacts(base, artifacts, outputType) {
 export function buildCompileOptions(parsed, base) {
     const hexPath = `${base}.hex`;
     const binPath = `${base}.bin`;
-    const lstPath = `${base}.lst`;
     return {
         includeDirs: parsed.includeDirs,
         directiveAliasFiles: parsed.directiveAliasFiles,
         emitBin: parsed.emitBin,
         emitHex: parsed.emitHex,
         emitD8m: parsed.emitD8m,
-        emitListing: parsed.emitListing,
         emitAsm80: parsed.emitAsm80,
         caseStyle: parsed.caseStyle,
         registerCare: parsed.registerCare,
@@ -165,7 +155,6 @@ export function buildCompileOptions(parsed, base) {
         ...(parsed.sourceRoot !== undefined
             ? {
                 d8mInputs: {
-                    ...(parsed.emitListing ? { listing: lstPath } : {}),
                     ...(parsed.emitHex ? { hex: hexPath } : {}),
                     ...(parsed.emitBin ? { bin: binPath } : {}),
                 },

package/dist/src/core/compile.js

@@ -4,15 +4,18 @@ import { createSourceFile } from '../source/source-file.js';
 import { scanLogicalLines } from '../source/logical-lines.js';
 import { stripLineComment } from '../source/strip-line-comment.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
-import { parseTypeExpr } from '../syntax/parse-expression.js';
+import { parseExpression, parseTypeExpr } from '../syntax/parse-expression.js';
 import { collectOps, expandOpInvocation, parseOpInvocation } from '../expansion/op-expansion.js';
+import { normalizeDirectiveAlias } from '../syntax/directive-aliases.js';
+import { evaluateExpression, lookupEquateRecord, } from '../semantics/expression-evaluation.js';
 export function parseNextSourceItems(lines, options = {}) {
     const diagnostics = [];
     const items = [];
-    const pendingLines = [...lines];
     const parseOptions = options.directiveAliasPolicy === undefined
         ? {}
         : { directiveAliasPolicy: options.directiveAliasPolicy };
+    const conditional = applyConditionalAssembly(lines, diagnostics, parseOptions.directiveAliasPolicy);
+    const pendingLines = [...conditional.lines];
     const { ops, opLineIndexes } = collectOps(pendingLines, diagnostics, parseOptions);
     let afterTopLevelEnd = false;
     for (let index = 0; index < pendingLines.length; index += 1) {
@@ -23,9 +26,61 @@ export function parseNextSourceItems(lines, options = {}) {
         if (afterTopLevelEnd && !isPostEndParseAllowed(line.text)) {
             continue;
         }
-        const layoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i.exec(stripLineComment(line.text).trim());
+        const colonLayoutHeader = /^([A-Za-z_][A-Za-z0-9_]*):\s*\.(type|union)\s*$/.exec(stripLineComment(line.text).trim());
+        if (colonLayoutHeader) {
+            const directive = colonLayoutHeader[2] ?? 'type';
+            diagnostics.push(parseDiagnostic(line, `Use "${colonLayoutHeader[1] ?? ''} .${directive}" for layouts; colon labels mark addresses.`));
+            const endDirective = directive === 'union' ? '.endunion' : '.endtype';
+            for (index += 1; index < pendingLines.length; index += 1) {
+                if (stripLineComment(pendingLines[index].text).trim() === endDirective) {
+                    break;
+                }
+            }
+            continue;
+        }
+        const nameLeftTypeAlias = /^([A-Za-z_][A-Za-z0-9_]*)\s+\.typealias\s+(.+)$/.exec(stripLineComment(line.text).trim());
+        if (nameLeftTypeAlias) {
+            const typeExprText = nameLeftTypeAlias[2] ?? '';
+            const typeExpr = parseTypeExpr(typeExprText);
+            if (!typeExpr) {
+                diagnostics.push(parseDiagnostic(line, `invalid .typealias target: ${typeExprText}`));
+            }
+            else {
+                items.push({
+                    kind: 'type-alias',
+                    name: nameLeftTypeAlias[1] ?? '',
+                    typeExpr,
+                    span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+                });
+            }
+            continue;
+        }
+        const typeAlias = /^\.type\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/.exec(stripLineComment(line.text).trim());
+        if (typeAlias) {
+            diagnostics.push(parseDiagnostic(line, `Use "${typeAlias[1] ?? ''} .typealias ..." for type aliases.`));
+            continue;
+        }
+        const nameLeftLayoutHeader = /^([A-Za-z_][A-Za-z0-9_]*)\s+\.(type|union)\s*$/.exec(stripLineComment(line.text).trim());
+        const prefixLayoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/.exec(stripLineComment(line.text).trim());
+        if (prefixLayoutHeader) {
+            const directive = prefixLayoutHeader[1] ?? 'type';
+            diagnostics.push(parseDiagnostic(line, `Use "${prefixLayoutHeader[2] ?? ''} .${directive}" for layouts.`));
+            const endDirective = directive === 'union' ? '.endunion' : '.endtype';
+            for (index += 1; index < pendingLines.length; index += 1) {
+                if (stripLineComment(pendingLines[index].text).trim() === endDirective) {
+                    break;
+                }
+            }
+            continue;
+        }
+        const layoutHeader = nameLeftLayoutHeader
+            ? {
+                directive: nameLeftLayoutHeader[2] ?? '',
+                name: nameLeftLayoutHeader[1] ?? '',
+            }
+            : undefined;
         if (layoutHeader) {
-            const layoutKind = (layoutHeader[1] ?? '').toLowerCase() === 'union' ? 'union' : 'record';
+            const layoutKind = layoutHeader.directive === 'union' ? 'union' : 'record';
             const endDirective = layoutKind === 'union' ? '.endunion' : '.endtype';
             const fields = [];
             let terminated = false;
@@ -35,23 +90,23 @@ export function parseNextSourceItems(lines, options = {}) {
                 if (fieldText.length === 0) {
                     continue;
                 }
-                if (fieldText.toLowerCase() === endDirective) {
+                if (fieldText === endDirective) {
                     terminated = true;
                     break;
                 }
                 const field = parseLayoutField(fieldText);
                 if (!field) {
-                    diagnostics.push(parseDiagnostic(fieldLine, `invalid .${layoutHeader[1]} field declaration`));
+                    diagnostics.push(parseDiagnostic(fieldLine, `invalid .${layoutHeader.directive} field declaration`));
                     continue;
                 }
                 fields.push(field);
             }
             if (!terminated) {
-                diagnostics.push(parseDiagnostic(line, `.${layoutHeader[1] ?? ''} ${layoutHeader[2] ?? ''} missing ${endDirective}`));
+                diagnostics.push(parseDiagnostic(line, `.${layoutHeader.directive} ${layoutHeader.name} missing ${endDirective}`));
             }
             items.push({
                 kind: 'type',
-                name: layoutHeader[2] ?? '',
+                name: layoutHeader.name,
                 layoutKind,
                 fields,
                 span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
@@ -78,6 +133,134 @@ export function parseNextSourceItems(lines, options = {}) {
     }
     return { diagnostics, items };
 }
+function applyConditionalAssembly(lines, diagnostics, directiveAliasPolicy) {
+    const out = [];
+    const equates = new Map();
+    const locationDependentEquates = new Set();
+    const stack = [];
+    for (const line of lines) {
+        const text = stripLineComment(line.text).trim();
+        const ifDirective = /^\.if\s+(.+)$/.exec(text);
+        if (ifDirective) {
+            const parentActive = conditionalActive(stack);
+            const expressionText = ifDirective[1] ?? '';
+            const value = parentActive
+                ? evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics)
+                : undefined;
+            const conditionActive = parentActive && value !== undefined && value !== 0;
+            stack.push({ line, parentActive, conditionActive, elseSeen: false });
+            continue;
+        }
+        if (/^\.else\s*$/.test(text)) {
+            const frame = stack.pop();
+            if (!frame) {
+                diagnostics.push(parseDiagnostic(line, 'unmatched .else'));
+                continue;
+            }
+            if (frame.elseSeen) {
+                diagnostics.push(parseDiagnostic(line, 'duplicate .else'));
+            }
+            stack.push({
+                line: frame.line,
+                parentActive: frame.parentActive,
+                conditionActive: frame.parentActive && !frame.conditionActive,
+                elseSeen: true,
+            });
+            continue;
+        }
+        if (/^\.endif\s*$/.test(text)) {
+            if (!stack.pop()) {
+                diagnostics.push(parseDiagnostic(line, 'unmatched .endif'));
+            }
+            continue;
+        }
+        if (!conditionalActive(stack)) {
+            continue;
+        }
+        out.push(line);
+        recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy);
+    }
+    for (const frame of stack) {
+        diagnostics.push(parseDiagnostic(frame.line, 'unterminated .if'));
+    }
+    return { lines: out };
+}
+function conditionalActive(stack) {
+    return stack.every((frame) => frame.parentActive && frame.conditionActive);
+}
+function evaluateConditionalExpression(line, expressionText, equates, locationDependentEquates, diagnostics) {
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        diagnostics.push(parseDiagnostic(line, `invalid .if expression: ${expressionText}`));
+        return undefined;
+    }
+    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
+        diagnostics.push(parseDiagnostic(line, 'invalid .if expression: current location is not available during conditional assembly'));
+        return undefined;
+    }
+    return evaluateExpression(expression, {}, equates, { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) }, diagnostics, { currentLocation: 0 });
+}
+function recordConditionalEquate(line, equates, locationDependentEquates, directiveAliasPolicy) {
+    const text = normalizeDirectiveAlias(stripLineComment(line.text), directiveAliasPolicy).trim();
+    const statement = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):\s*(.+)$/.exec(text);
+    if (statement && /^\.equ\b/.test(statement[2] ?? '')) {
+        return;
+    }
+    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/.exec(text);
+    if (!equ) {
+        return;
+    }
+    const name = equ[1] ?? '';
+    const expressionText = equ[2] ?? '';
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        return;
+    }
+    if (expressionReferencesCurrentLocation(expression, equates, locationDependentEquates)) {
+        locationDependentEquates.add(canonicalConditionalSymbolKey(name));
+    }
+    equates.set(name, {
+        expression,
+        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+        currentLocation: 0,
+    });
+}
+function expressionReferencesCurrentLocation(expression, equates, locationDependentEquates, visiting = new Set()) {
+    switch (expression.kind) {
+        case 'current-location':
+            return true;
+        case 'symbol': {
+            if (locationDependentEquates.has(canonicalConditionalSymbolKey(expression.name))) {
+                return true;
+            }
+            const lookup = lookupEquateRecord(equates, expression.name);
+            if (!lookup || visiting.has(canonicalConditionalSymbolKey(lookup.key))) {
+                return false;
+            }
+            const nextVisiting = new Set(visiting);
+            nextVisiting.add(canonicalConditionalSymbolKey(lookup.key));
+            return expressionReferencesCurrentLocation(lookup.record.expression, equates, locationDependentEquates, nextVisiting);
+        }
+        case 'byte-function':
+        case 'unary':
+            return expressionReferencesCurrentLocation(expression.expression, equates, locationDependentEquates, visiting);
+        case 'binary':
+            return (expressionReferencesCurrentLocation(expression.left, equates, locationDependentEquates, visiting) ||
+                expressionReferencesCurrentLocation(expression.right, equates, locationDependentEquates, visiting));
+        case 'layout-cast':
+            return (expressionReferencesCurrentLocation(expression.base, equates, locationDependentEquates, visiting) ||
+                expression.path.some((part) => part.kind === 'index' &&
+                    expressionReferencesCurrentLocation(part.expression, equates, locationDependentEquates, visiting)));
+        case 'number':
+        case 'type-size':
+        case 'sizeof':
+        case 'offset':
+            return false;
+    }
+}
+function canonicalConditionalSymbolKey(name) {
+    return name.toLowerCase();
+}
 export function compileSource(sourceText, options = {}) {
     const source = createSourceFile(options.entryName ?? '<memory>', sourceText);
     const { diagnostics, items } = parseNextSourceItems(scanLogicalLines(source));
@@ -107,7 +290,7 @@ function isPostEndParseAllowed(text) {
     return /^(?:\.binfrom|\.binto|binfrom|binto)\b/i.test(stripLineComment(text).trim());
 }
 function parseLayoutField(text) {
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/i.exec(text);
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/.exec(text);
     if (!match) {
         return undefined;
     }

package/dist/src/expansion/op-expansion.js

@@ -667,6 +667,7 @@ function renameSourceItem(item, localLabelMap) {
         case 'end':
         case 'enum':
         case 'type':
+        case 'type-alias':
         case 'string-data':
             return item;
     }

package/dist/src/model/expression.d.ts

@@ -12,6 +12,10 @@ export type Expression = {
 } | {
     readonly kind: 'sizeof';
     readonly typeExpr: TypeExpr;
+} | {
+    readonly kind: 'byte-function';
+    readonly function: 'LSB' | 'MSB';
+    readonly expression: Expression;
 } | {
     readonly kind: 'offset';
     readonly typeExpr: TypeExpr;

package/dist/src/model/source-item.d.ts

@@ -60,6 +60,11 @@ export type SourceItem = {
     readonly layoutKind: 'record' | 'union';
     readonly fields: readonly LayoutField[];
     readonly span: SourceSpan;
+} | {
+    readonly kind: 'type-alias';
+    readonly name: string;
+    readonly typeExpr: TypeExpr;
+    readonly span: SourceSpan;
 } | {
     readonly kind: 'string-data';
     readonly directive: 'cstr' | 'pstr' | 'istr';

package/dist/src/outputs/index.js

@@ -1,13 +1,11 @@
 import { writeBin } from './write-bin.js';
 import { writeD8m } from './write-d8.js';
 import { writeHex } from './write-hex.js';
-import { writeListing } from './write-listing.js';
 import { writeAsm80 } from './write-asm80.js';
 /** Default in-memory writers for Stage 12 compile API. */
 export const defaultFormatWriters = {
     writeBin,
     writeHex,
     writeD8m,
-    writeListing,
     writeAsm80,
 };

package/dist/src/outputs/types.d.ts

@@ -21,7 +21,7 @@ export interface EmittedSourceSegment {
     kind: D8mSegmentKind;
     confidence: D8mSegmentConfidence;
 }
-/** Symbol metadata shared by listing and D8 writers. */
+/** Symbol metadata shared by output writers. */
 export type SymbolEntry = {
     kind: 'label' | 'data';
     name: string;
@@ -50,12 +50,6 @@ export interface HexArtifact {
     path?: string;
     text: string;
 }
-/** Listing artifact. */
-export interface ListingArtifact {
-    kind: 'lst';
-    path?: string;
-    text: string;
-}
 /** In-memory register-care audit report artifact. */
 export interface RegisterCareReportArtifact {
     kind: 'register-care-report';
@@ -122,7 +116,6 @@ export interface D8mGenerator {
     version?: string;
     inputs?: {
         entry?: string;
-        listing?: string;
         hex?: string;
         bin?: string;
     };
@@ -153,16 +146,11 @@ export interface WriteBinOptions {
     binFrom?: number;
     startAddress?: number;
 }
-export interface WriteListingOptions {
-    lineEnding?: '\n' | '\r\n';
-    bytesPerLine?: number;
-}
 export interface WriteD8mOptions {
     rootDir?: string;
     packageVersion?: string;
     inputs?: {
         entry?: string;
-        listing?: string;
         hex?: string;
         bin?: string;
     };
@@ -171,12 +159,11 @@ export interface WriteD8mOptions {
 }
 export interface WriteAsm80Options {
 }
-export type Artifact = BinArtifact | HexArtifact | ListingArtifact | D8mArtifact | Asm80Artifact | RegisterCareReportArtifact | RegisterCareInterfaceArtifact | RegisterCareAnnotationsArtifact;
-/** Writer contract used by the Stage 12 compile API. */
+export type Artifact = BinArtifact | HexArtifact | D8mArtifact | Asm80Artifact | RegisterCareReportArtifact | RegisterCareInterfaceArtifact | RegisterCareAnnotationsArtifact;
+/** Writer contract used by the compile API. */
 export interface FormatWriters {
     writeHex(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteHexOptions): HexArtifact;
     writeBin(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteBinOptions): BinArtifact;
     writeD8m(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteD8mOptions): D8mArtifact;
-    writeListing?(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteListingOptions): ListingArtifact;
     writeAsm80?(items: readonly SourceItem[], symbols: readonly SymbolEntry[], opts?: WriteAsm80Options): Asm80Artifact;
 }