@jhlagado/azm 0.2.1 → 0.2.3

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'],
   },
@@ -125,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',
     },
@@ -257,7 +254,7 @@ 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/listing artifacts alongside the asm80 error. Run
+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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhlagado/azm",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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"
   ],
@@ -86,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 check:asm80-coverage && 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",
@@ -95,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;

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

@@ -1,186 +0,0 @@
-import { dirname, extname } from 'node:path';
-import { readFile } from 'node:fs/promises';
-import { analyzeLoadedProgram } from './analysis.js';
-import { hasErrors, normalizePath } from './compileShared.js';
-import { DiagnosticIds } from './diagnosticTypes.js';
-import { buildDirectiveAliasPolicy, defaultDirectiveAliasProfileName, readDirectiveAliasProfile, } from './frontend/directiveAliases.js';
-import { isSupportedSourcePath } from './frontend/sourceExtensions.js';
-import { emitProgram } from './lowering/emit.js';
-import { loadProgram } from './sourceLoader.js';
-import { analyzeRegisterCare } from './registerCare/analyze.js';
-import { parseInterfaceContracts } from './registerCare/smartComments.js';
-import { readPackageVersion } from './packageInfo.js';
-function withDefaults(options) {
-    const anyPrimaryEmitSpecified = [options.emitBin, options.emitHex, options.emitD8m].some((v) => v !== undefined);
-    const emitBin = anyPrimaryEmitSpecified ? (options.emitBin ?? false) : true;
-    const emitHex = anyPrimaryEmitSpecified ? (options.emitHex ?? false) : true;
-    const emitD8m = anyPrimaryEmitSpecified ? (options.emitD8m ?? false) : true;
-    // Listing is a sidecar artifact: default to on unless explicitly suppressed.
-    const emitListing = options.emitListing ?? true;
-    const emitAsm80 = options.emitAsm80 ?? false;
-    return { emitBin, emitHex, emitD8m, emitListing, emitAsm80 };
-}
-/**
- * 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 const compile = async (entryFile, options, deps) => {
-    const entryPath = normalizePath(entryFile);
-    const diagnostics = [];
-    const artifacts = [];
-    if (!isSupportedSourcePath(entryPath)) {
-        diagnostics.push({
-            id: DiagnosticIds.Unknown,
-            severity: 'error',
-            message: 'Unsupported source file extension (expected .asm or .z80)',
-            file: entryPath,
-        });
-        return { diagnostics, artifacts };
-    }
-    const projectAliasProfiles = [];
-    for (const path of options.directiveAliasFiles ?? []) {
-        projectAliasProfiles.push(await readDirectiveAliasProfile(normalizePath(path)));
-    }
-    const directiveAliasPolicy = buildDirectiveAliasPolicy(defaultDirectiveAliasProfileName(), projectAliasProfiles);
-    const loaded = await loadProgram(entryPath, diagnostics, {
-        ...options,
-        directiveAliasPolicy,
-    });
-    if (!loaded)
-        return { diagnostics, artifacts };
-    const { program, sourceTexts, sourceLineComments } = loaded;
-    if (hasErrors(diagnostics)) {
-        return { diagnostics, artifacts };
-    }
-    const analysis = analyzeLoadedProgram(loaded, {
-        ...(options.caseStyle !== undefined ? { caseStyle: options.caseStyle } : {}),
-        ...(options.requireMain !== undefined ? { requireMain: options.requireMain } : {}),
-    });
-    diagnostics.push(...analysis.diagnostics);
-    if (hasErrors(diagnostics) || !analysis.env)
-        return { diagnostics, artifacts };
-    const env = analysis.env;
-    const registerCareMode = options.registerCare ?? 'off';
-    const shouldAnalyzeRegisterCare = registerCareMode !== 'off' ||
-        options.emitRegisterReport === true ||
-        options.emitRegisterInterface === true ||
-        options.emitRegisterAnnotations === true ||
-        options.fixRegisterContracts === true ||
-        (options.acceptRegisterOutputCandidates?.length ?? 0) > 0 ||
-        (options.registerCareInterfaces?.length ?? 0) > 0;
-    if (shouldAnalyzeRegisterCare) {
-        const interfaceContracts = [];
-        for (const path of options.registerCareInterfaces ?? []) {
-            const resolved = normalizePath(path);
-            if (extname(resolved).toLowerCase() !== '.asmi') {
-                diagnostics.push({
-                    id: DiagnosticIds.Unknown,
-                    severity: 'error',
-                    message: 'Register-care interface files must use the .asmi extension',
-                    file: resolved,
-                });
-                continue;
-            }
-            const text = await readFile(resolved, 'utf8');
-            interfaceContracts.push(...parseInterfaceContracts(text, resolved).values());
-        }
-        if (hasErrors(diagnostics))
-            return { diagnostics, artifacts };
-        const registerCare = analyzeRegisterCare(loaded, {
-            mode: registerCareMode,
-            emitReport: options.emitRegisterReport === true,
-            emitInterface: options.emitRegisterInterface === true,
-            emitAnnotations: options.emitRegisterAnnotations === true || options.fixRegisterContracts === true,
-            fixRegisterContracts: options.fixRegisterContracts === true,
-            ...(options.acceptRegisterOutputCandidates !== undefined
-                ? { acceptOutputCandidates: options.acceptRegisterOutputCandidates }
-                : {}),
-            ...(options.registerCareProfile !== undefined
-                ? { profile: options.registerCareProfile }
-                : {}),
-            ...(interfaceContracts.length > 0 ? { interfaceContracts } : {}),
-        });
-        diagnostics.push(...registerCare.diagnostics);
-        if (registerCare.reportText !== undefined) {
-            artifacts.push({ kind: 'register-care-report', text: registerCare.reportText });
-        }
-        if (registerCare.interfaceText !== undefined) {
-            artifacts.push({ kind: 'register-care-interface', text: registerCare.interfaceText });
-        }
-        if (registerCare.annotatedFiles !== undefined) {
-            artifacts.push({ kind: 'register-care-annotations', files: registerCare.annotatedFiles });
-        }
-        if (hasErrors(diagnostics)) {
-            return { diagnostics, artifacts };
-        }
-    }
-    const { map, symbols, placedLoweredAsmProgram } = emitProgram(program, env, diagnostics, {
-        ...(options.includeDirs ? { includeDirs: options.includeDirs } : {}),
-        ...(options.defaultCodeBase !== undefined ? { defaultCodeBase: options.defaultCodeBase } : {}),
-        sourceTexts,
-        sourceLineComments,
-    });
-    if (hasErrors(diagnostics)) {
-        return { diagnostics, artifacts };
-    }
-    const emit = withDefaults(options);
-    if (emit.emitBin) {
-        artifacts.push(deps.formats.writeBin(map, symbols));
-    }
-    if (emit.emitHex) {
-        artifacts.push(deps.formats.writeHex(map, symbols));
-    }
-    if (emit.emitD8m) {
-        const mainEntry = symbols.find((s) => s.kind === 'label' && s.name.toLowerCase() === 'main');
-        const d8mRoot = options.sourceRoot ?? dirname(entryPath);
-        artifacts.push(deps.formats.writeD8m(map, symbols, {
-            rootDir: d8mRoot,
-            packageVersion: readPackageVersion(),
-            inputs: {
-                entry: entryPath,
-                ...(options.d8mInputs?.listing !== undefined
-                    ? { listing: options.d8mInputs.listing }
-                    : {}),
-                ...(options.d8mInputs?.hex !== undefined ? { hex: options.d8mInputs.hex } : {}),
-                ...(options.d8mInputs?.bin !== undefined ? { bin: options.d8mInputs.bin } : {}),
-            },
-            ...(mainEntry
-                ? {
-                    entrySymbol: mainEntry.name,
-                    entryAddress: mainEntry.address & 0xffff,
-                }
-                : {}),
-        }));
-    }
-    if (emit.emitListing) {
-        if (deps.formats.writeListing) {
-            artifacts.push(deps.formats.writeListing(map, symbols));
-        }
-        else {
-            diagnostics.push({
-                id: DiagnosticIds.Unknown,
-                severity: 'warning',
-                message: 'emitListing=true but no listing writer is configured; skipping .lst artifact.',
-                file: program.entryFile,
-            });
-        }
-    }
-    if (emit.emitAsm80) {
-        if (deps.formats.writeAsm80) {
-            artifacts.push(deps.formats.writeAsm80(placedLoweredAsmProgram));
-        }
-        else {
-            diagnostics.push({
-                id: DiagnosticIds.Unknown,
-                severity: 'warning',
-                message: 'emitAsm80=true but no asm80 writer is configured; skipping .asm artifact.',
-                file: program.entryFile,
-            });
-        }
-    }
-    return { diagnostics, artifacts };
-};

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

@@ -1,3 +0,0 @@
-import type { Diagnostic } from './diagnosticTypes.js';
-export declare function hasErrors(diagnostics: Diagnostic[]): boolean;
-export declare function normalizePath(p: string): string;

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

@@ -1,7 +0,0 @@
-import { resolve } from 'node:path';
-export function hasErrors(diagnostics) {
-    return diagnostics.some((d) => d.severity === 'error');
-}
-export function normalizePath(p) {
-    return resolve(p);
-}

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

@@ -1,77 +0,0 @@
-/**
- * Severity level for a diagnostic.
- */
-export type DiagnosticSeverity = 'error' | 'warning' | 'info';
-/**
- * A compiler diagnostic (error/warning/info) with an optional source location.
- *
- * Diagnostics must have stable IDs so downstream tooling can rely on them.
- */
-export interface Diagnostic {
-    /** Stable diagnostic identifier (e.g., `AZM001`). */
-    id: DiagnosticId;
-    severity: DiagnosticSeverity;
-    message: string;
-    file: string;
-    /** 1-based line number, when known. */
-    line?: number;
-    /** 1-based column number, when known. */
-    column?: number;
-}
-/**
- * Known diagnostic IDs.
- *
- * PR0 started with a minimal set; later PRs should extend this via contract changes.
- */
-export declare const DiagnosticIds: {
-    /**
-     * Unknown/unclassified diagnostic.
-     *
-     * Use a more specific ID when possible; this remains for forward compatibility.
-     */
-    readonly Unknown: "AZM000";
-    /** Failed to read a source file from disk. */
-    readonly IoReadFailed: "AZM001";
-    /** Internal error during parsing (unexpected exception). */
-    readonly InternalParseError: "AZM002";
-    /** Include could not be resolved on any search path. */
-    readonly IncludeNotFound: "AZM003";
-    /** Generic parse error (syntax / unsupported in current PR subset). */
-    readonly ParseError: "AZM100";
-    /** Generic instruction encoding error (unsupported mnemonic/operands, out-of-range imm, etc.). */
-    readonly EncodeError: "AZM200";
-    /** Generic emission/lowering error (layout/packing/symbol collisions, etc.). */
-    readonly EmitError: "AZM300";
-    /** Generic emission/lowering warning. */
-    readonly EmitWarning: "AZM301";
-    /** Op invocation arity mismatch against available overload set. */
-    readonly OpArityMismatch: "AZM310";
-    /** No overload match for an op invocation with the provided operands. */
-    readonly OpNoMatchingOverload: "AZM311";
-    /** Ambiguous overload resolution for an op invocation. */
-    readonly OpAmbiguousOverload: "AZM312";
-    /** Cyclic op expansion detected in inline expansion graph. */
-    readonly OpExpansionCycle: "AZM313";
-    /** Op expansion produced an invalid concrete instruction after substitution. */
-    readonly OpInvalidExpansion: "AZM314";
-    /** Generic semantic evaluation error (env building, imm evaluation, etc.). */
-    readonly SemanticsError: "AZM400";
-    /** Divide by zero in an imm expression. */
-    readonly ImmDivideByZero: "AZM401";
-    /** Modulo by zero in an imm expression. */
-    readonly ImmModuloByZero: "AZM402";
-    /** Type/layout error (unknown type, recursion, missing array length, etc.). */
-    readonly TypeError: "AZM403";
-    /** Case-style lint warning for keyword/register casing policy. */
-    readonly CaseStyleLint: "AZM500";
-    /** Redundant outer parentheses in a constant-only array index expression. */
-    readonly IndexParenRedundant: "AZM501";
-    /** Register-care conflict where a call may destroy a live caller value. */
-    readonly RegisterCareConflict: "AZM600";
-    /** Register-care analysis cannot prove an external or indirect call contract. */
-    readonly RegisterCareUnknownBoundary: "AZM601";
-};
-/**
- * Union type of all defined diagnostic IDs.
- */
-export type DiagnosticId = (typeof DiagnosticIds)[keyof typeof DiagnosticIds];

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

@@ -1,53 +0,0 @@
-/**
- * Known diagnostic IDs.
- *
- * PR0 started with a minimal set; later PRs should extend this via contract changes.
- */
-export const DiagnosticIds = {
-    /**
-     * Unknown/unclassified diagnostic.
-     *
-     * Use a more specific ID when possible; this remains for forward compatibility.
-     */
-    Unknown: 'AZM000',
-    /** Failed to read a source file from disk. */
-    IoReadFailed: 'AZM001',
-    /** Internal error during parsing (unexpected exception). */
-    InternalParseError: 'AZM002',
-    /** Include could not be resolved on any search path. */
-    IncludeNotFound: 'AZM003',
-    /** Generic parse error (syntax / unsupported in current PR subset). */
-    ParseError: 'AZM100',
-    /** Generic instruction encoding error (unsupported mnemonic/operands, out-of-range imm, etc.). */
-    EncodeError: 'AZM200',
-    /** Generic emission/lowering error (layout/packing/symbol collisions, etc.). */
-    EmitError: 'AZM300',
-    /** Generic emission/lowering warning. */
-    EmitWarning: 'AZM301',
-    /** Op invocation arity mismatch against available overload set. */
-    OpArityMismatch: 'AZM310',
-    /** No overload match for an op invocation with the provided operands. */
-    OpNoMatchingOverload: 'AZM311',
-    /** Ambiguous overload resolution for an op invocation. */
-    OpAmbiguousOverload: 'AZM312',
-    /** Cyclic op expansion detected in inline expansion graph. */
-    OpExpansionCycle: 'AZM313',
-    /** Op expansion produced an invalid concrete instruction after substitution. */
-    OpInvalidExpansion: 'AZM314',
-    /** Generic semantic evaluation error (env building, imm evaluation, etc.). */
-    SemanticsError: 'AZM400',
-    /** Divide by zero in an imm expression. */
-    ImmDivideByZero: 'AZM401',
-    /** Modulo by zero in an imm expression. */
-    ImmModuloByZero: 'AZM402',
-    /** Type/layout error (unknown type, recursion, missing array length, etc.). */
-    TypeError: 'AZM403',
-    /** Case-style lint warning for keyword/register casing policy. */
-    CaseStyleLint: 'AZM500',
-    /** Redundant outer parentheses in a constant-only array index expression. */
-    IndexParenRedundant: 'AZM501',
-    /** Register-care conflict where a call may destroy a live caller value. */
-    RegisterCareConflict: 'AZM600',
-    /** Register-care analysis cannot prove an external or indirect call contract. */
-    RegisterCareUnknownBoundary: 'AZM601',
-};

package/dist/legacy-root-azm/src/formats/index.d.ts

@@ -1,7 +0,0 @@
-import type { FormatWriters } from './types.js';
-/**
- * Default in-memory artifact writers.
- *
- * These writers implement the `FormatWriters` contract and return artifacts without writing to disk.
- */
-export declare const defaultFormatWriters: FormatWriters;

package/dist/legacy-root-azm/src/formats/index.js

@@ -1,17 +0,0 @@
-import { writeBin } from './writeBin.js';
-import { writeD8m } from './writeD8m.js';
-import { writeHex } from './writeHex.js';
-import { writeListing } from './writeListing.js';
-import { writeAsm80 } from './writeAsm80.js';
-/**
- * Default in-memory artifact writers.
- *
- * These writers implement the `FormatWriters` contract and return artifacts without writing to disk.
- */
-export const defaultFormatWriters = {
-    writeHex,
-    writeBin,
-    writeD8m,
-    writeListing,
-    writeAsm80,
-};

package/dist/legacy-root-azm/src/formats/range.d.ts

@@ -1,17 +0,0 @@
-import type { AddressRange, EmittedByteMap } from './types.js';
-/**
- * Compute contiguous written segments from an emitted byte map.
- *
- * - Segments are half-open `[start, end)`.
- * - Segment boundaries are based on concrete written byte addresses.
- * - For an empty map, `[]` is returned.
- */
-export declare function getWrittenSegments(map: EmittedByteMap): AddressRange[];
-/**
- * Compute the effective written range for an emitted byte map.
- *
- * - If `map.writtenRange` is present, it is returned directly.
- * - Otherwise, the range is derived from the min/max written addresses.
- * - For an empty map, `{ start: 0, end: 0 }` is returned.
- */
-export declare function getWrittenRange(map: EmittedByteMap): AddressRange;

package/dist/legacy-root-azm/src/formats/range.js

@@ -1,45 +0,0 @@
-/**
- * Compute contiguous written segments from an emitted byte map.
- *
- * - Segments are half-open `[start, end)`.
- * - Segment boundaries are based on concrete written byte addresses.
- * - For an empty map, `[]` is returned.
- */
-export function getWrittenSegments(map) {
-    if (map.bytes.size === 0)
-        return [];
-    const sorted = [...new Set(map.bytes.keys())].sort((a, b) => a - b);
-    const segments = [];
-    let start = sorted[0];
-    let prev = start;
-    for (let index = 1; index < sorted.length; index++) {
-        const addr = sorted[index];
-        if (addr <= prev + 1) {
-            prev = addr;
-            continue;
-        }
-        segments.push({ start, end: prev + 1 });
-        start = addr;
-        prev = addr;
-    }
-    segments.push({ start, end: prev + 1 });
-    return segments;
-}
-/**
- * Compute the effective written range for an emitted byte map.
- *
- * - If `map.writtenRange` is present, it is returned directly.
- * - Otherwise, the range is derived from the min/max written addresses.
- * - For an empty map, `{ start: 0, end: 0 }` is returned.
- */
-export function getWrittenRange(map) {
-    if (map.writtenRange)
-        return map.writtenRange;
-    const segments = getWrittenSegments(map);
-    if (segments.length === 0)
-        return { start: 0, end: 0 };
-    return {
-        start: segments[0].start,
-        end: segments[segments.length - 1].end,
-    };
-}