@jhlagado/azm 0.2.1 → 0.2.3

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

@@ -1,283 +0,0 @@
-/**
- * Half-open address range in the Z80 16-bit address space.
- */
-export interface AddressRange {
-    /** Inclusive start address. */
-    start: number;
-    /** Exclusive end address. */
-    end: number;
-}
-/**
- * Address->byte map for all emitted machine-code bytes.
- */
-export interface EmittedByteMap {
-    /**
-     * Address -> byte (0..255). Addresses are 0..65535 for Z80.
-     */
-    bytes: Map<number, number>;
-    writtenRange?: AddressRange;
-    /**
-     * Optional source-attributed code segments emitted by lowering.
-     *
-     * Addresses are absolute in the final 16-bit address space.
-     */
-    sourceSegments?: EmittedSourceSegment[];
-}
-/**
- * Source-attributed emitted range used by debug-map writers.
- */
-export interface EmittedSourceSegment {
-    start: number;
-    end: number;
-    file: string;
-    line: number;
-    column: number;
-    kind: 'code' | 'data' | 'directive' | 'label' | 'macro' | 'unknown';
-    confidence: 'high' | 'medium' | 'low';
-}
-/**
- * A symbol entry for debug maps and listings.
- */
-export type SymbolEntry = {
-    kind: 'constant';
-    name: string;
-    /**
-     * Constant value (not an address).
-     *
-     * D8M serialization includes this as `value`.
-     */
-    value: number;
-    file?: string;
-    line?: number;
-    scope?: 'global' | 'local';
-} | {
-    kind: 'label' | 'data' | 'unknown';
-    name: string;
-    address: number;
-    file?: string;
-    line?: number;
-    scope?: 'global' | 'local';
-    size?: number;
-};
-/**
- * Options for Intel HEX writing.
- */
-export interface WriteHexOptions {
-    /**
-     * Line ending to use when emitting text formats.
-     */
-    lineEnding?: '\n' | '\r\n';
-}
-/** Options for BIN writing. */
-export interface WriteBinOptions {
-}
-/** Options for D8M writing. */
-export interface WriteD8mOptions {
-    /**
-     * Base directory used to normalize file paths in D8M symbol entries.
-     * When provided, file paths are made project-relative and use `/` separators.
-     */
-    rootDir?: string;
-    /**
-     * AZM package version to record in generator metadata.
-     */
-    packageVersion?: string;
-    /**
-     * Source/output paths used to produce this map.
-     *
-     * Paths are normalized with `rootDir` when present.
-     */
-    inputs?: {
-        entry?: string;
-        listing?: string;
-        hex?: string;
-        bin?: string;
-    };
-    /**
-     * Optional runnable entry symbol metadata for harnesses.
-     */
-    entrySymbol?: string;
-    /**
-     * Optional resolved entry address metadata for harnesses.
-     */
-    entryAddress?: number;
-}
-/**
- * Options for listing writing.
- *
- * Note: the listing format is currently a deterministic byte dump plus a symbol table.
- */
-export interface WriteListingOptions {
-    /**
-     * Line ending to use when emitting text formats.
-     */
-    lineEnding?: '\n' | '\r\n';
-    /**
-     * Number of bytes shown per listing line.
-     */
-    bytesPerLine?: number;
-}
-/**
- * Options for ASM80 source emission.
- */
-export interface WriteAsm80Options {
-    /**
-     * Line ending to use when emitting text formats.
-     */
-    lineEnding?: '\n' | '\r\n';
-}
-/**
- * In-memory Intel HEX artifact.
- */
-export interface HexArtifact {
-    kind: 'hex';
-    path?: string;
-    text: string;
-}
-/**
- * In-memory flat binary artifact.
- */
-export interface BinArtifact {
-    kind: 'bin';
-    path?: string;
-    bytes: Uint8Array;
-}
-/**
- * In-memory listing artifact.
- */
-export interface ListingArtifact {
-    kind: 'lst';
-    path?: string;
-    text: string;
-}
-/**
- * In-memory ASM80 `.z80` artifact.
- */
-export interface Asm80Artifact {
-    kind: 'asm80';
-    path?: string;
-    text: string;
-}
-/**
- * In-memory D8 Debug Map (D8M) artifact.
- */
-export interface D8mArtifact {
-    kind: 'd8m';
-    path?: string;
-    json: D8mJson;
-}
-export type D8mSegmentKind = 'code' | 'data' | 'directive' | 'label' | 'macro' | 'unknown';
-export type D8mSegmentConfidence = 'high' | 'medium' | 'low';
-export interface D8mSegment {
-    start: number;
-    end: number;
-    lstLine: number;
-    /** 1-based original source line when known. */
-    line?: number;
-    kind: D8mSegmentKind;
-    confidence: D8mSegmentConfidence;
-}
-export type D8mSymbol = {
-    name: string;
-    kind: 'constant';
-    value: number;
-    file?: string;
-    line?: number;
-    scope?: 'global' | 'local';
-} | {
-    name: string;
-    kind: 'label' | 'data' | 'unknown';
-    address: number;
-    file?: string;
-    line?: number;
-    scope?: 'global' | 'local';
-    size?: number;
-};
-export type D8mFileSymbol = {
-    name: string;
-    kind: 'constant';
-    value: number;
-    line?: number;
-    scope?: 'global' | 'local';
-} | {
-    name: string;
-    kind: 'label' | 'data' | 'unknown';
-    address: number;
-    line?: number;
-    scope?: 'global' | 'local';
-    size?: number;
-};
-export interface D8mFileEntry {
-    segments?: D8mSegment[];
-    symbols?: D8mFileSymbol[];
-}
-export interface D8mGenerator {
-    name: 'azm';
-    tool: 'azm';
-    version?: string;
-    inputs?: {
-        entry?: string;
-        listing?: string;
-        hex?: string;
-        bin?: string;
-    };
-    entrySymbol?: string;
-    entryAddress?: number;
-}
-/**
- * In-memory register-care audit report artifact.
- */
-export interface RegisterCareReportArtifact {
-    kind: 'register-care-report';
-    path?: string;
-    text: string;
-}
-/**
- * In-memory inferred register-care interface artifact.
- */
-export interface RegisterCareInterfaceArtifact {
-    kind: 'register-care-interface';
-    path?: string;
-    text: string;
-}
-/**
- * In-memory register-care source annotation artifact.
- */
-export interface RegisterCareAnnotationsArtifact {
-    kind: 'register-care-annotations';
-    files: Array<{
-        path: string;
-        text: string;
-    }>;
-}
-/**
- * Union of all artifact kinds produced by the compiler.
- */
-export type Artifact = HexArtifact | BinArtifact | ListingArtifact | D8mArtifact | Asm80Artifact | RegisterCareReportArtifact | RegisterCareInterfaceArtifact | RegisterCareAnnotationsArtifact;
-/**
- * Minimal D8 Debug Map (D8M) v1 JSON shape.
- *
- * Writers may add additional keys as needed.
- */
-export type D8mJson = {
-    format: 'd8-debug-map';
-    version: 1;
-    arch: 'z80';
-    addressWidth: 16;
-    endianness: 'little';
-    files: Record<string, D8mFileEntry>;
-    segments: AddressRange[];
-    fileList?: string[];
-    symbols: D8mSymbol[];
-    generator: D8mGenerator;
-};
-/**
- * Format writers used by the pipeline to turn emitted bytes/symbols into artifacts.
- */
-export interface FormatWriters {
-    writeHex(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteHexOptions): HexArtifact;
-    writeBin(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteBinOptions): BinArtifact;
-    writeD8m(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteD8mOptions): D8mArtifact;
-    writeListing?(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteListingOptions): ListingArtifact;
-    writeAsm80?(program: import('../lowering/loweredAsmTypes.js').LoweredAsmProgram, opts?: WriteAsm80Options): Asm80Artifact;
-}

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,6 +0,0 @@
-import type { Asm80Artifact, WriteAsm80Options } from './types.js';
-import type { LoweredAsmProgram } from '../lowering/loweredAsmTypes.js';
-/**
- * Emit ASM80-compatible source from a placed lowered assembly program.
- */
-export declare function writeAsm80(program: LoweredAsmProgram, opts?: WriteAsm80Options): Asm80Artifact;

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

@@ -1,86 +0,0 @@
-import { formatLoweredImmExpr, formatLoweredNumber } from '../lowering/loweredFormat.js';
-const toHexByte = (value) => value.toString(16).toUpperCase().padStart(2, '0');
-function formatEaExpr(expr) {
-    switch (expr.kind) {
-        case 'name':
-            return expr.name;
-        case 'imm':
-            return formatLoweredImmExpr(expr.expr);
-        case 'add':
-            return `${formatEaExpr(expr.base)}+${formatLoweredImmExpr(expr.offset)}`;
-        case 'sub':
-            return `${formatEaExpr(expr.base)}-${formatLoweredImmExpr(expr.offset)}`;
-        case 'field':
-        case 'index':
-        case 'layoutCast':
-            throw new Error(`ASM80 emitter cannot format lowered EA kind "${expr.kind}".`);
-    }
-}
-function formatOperand(op) {
-    switch (op.kind) {
-        case 'reg':
-            return op.name.toLowerCase();
-        case 'imm':
-            return formatLoweredImmExpr(op.expr);
-        case 'ea':
-            return formatEaExpr(op.expr);
-        case 'mem':
-            return `(${formatEaExpr(op.expr)})`;
-        case 'portImm8':
-            return `(${formatLoweredImmExpr(op.expr)})`;
-        case 'portC':
-            return '(c)';
-    }
-}
-function formatItem(item) {
-    switch (item.kind) {
-        case 'label':
-            return [`${item.name}:`];
-        case 'const':
-            return [`${item.name} EQU ${formatLoweredImmExpr(item.value)}`];
-        case 'comment':
-            if (!item.text.trim())
-                return [];
-            if (item.origin === 'user')
-                return [`; ${item.text}`];
-            return [`; AZM: ${item.text}`];
-        case 'db':
-            return [`DB ${item.values.map(formatLoweredImmExpr).join(', ')}`];
-        case 'dw':
-            return [`DW ${item.values.map(formatLoweredImmExpr).join(', ')}`];
-        case 'ds':
-            return [
-                item.fill === undefined
-                    ? `DS ${formatLoweredImmExpr(item.size)}`
-                    : `DS ${formatLoweredImmExpr(item.size)}, ${formatLoweredImmExpr(item.fill)}`,
-            ];
-        case 'instr': {
-            if (item.head === '@raw') {
-                const bytes = item.bytes ?? [];
-                if (bytes.length === 0)
-                    return [];
-                const parts = bytes.map((b) => `$${toHexByte(b & 0xff)}`);
-                return [`DB ${parts.join(', ')}`];
-            }
-            const head = item.head.toLowerCase();
-            const ops = item.operands.map(formatOperand);
-            return [ops.length ? `${head} ${ops.join(', ')}` : head];
-        }
-    }
-}
-/**
- * Emit ASM80-compatible source from a placed lowered assembly program.
- */
-export function writeAsm80(program, opts) {
-    const lineEnding = opts?.lineEnding ?? '\n';
-    const lines = [];
-    lines.push('; AZM lowered ASM80 output');
-    for (const block of program.blocks) {
-        lines.push('');
-        lines.push(`ORG ${formatLoweredNumber(block.origin)}`);
-        for (const item of block.items) {
-            lines.push(...formatItem(item));
-        }
-    }
-    return { kind: 'asm80', text: lines.join(lineEnding) + lineEnding };
-}

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

@@ -1,7 +0,0 @@
-import type { BinArtifact, EmittedByteMap, SymbolEntry, WriteBinOptions } from './types.js';
-/**
- * Create a flat binary artifact from an emitted address->byte map.
- *
- * Bytes are emitted for the computed written range; unwritten addresses inside the range are `0x00`.
- */
-export declare function writeBin(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteBinOptions): BinArtifact;

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

@@ -1,23 +0,0 @@
-import { getWrittenRange } from './range.js';
-const BINFROM_SYMBOL_NAME = '__azm_binfrom';
-const BINTO_SYMBOL_NAME = '__azm_binto';
-/**
- * Create a flat binary artifact from an emitted address->byte map.
- *
- * Bytes are emitted for the computed written range; unwritten addresses inside the range are `0x00`.
- */
-export function writeBin(map, symbols, opts) {
-    const { start: writtenStart, end } = getWrittenRange(map);
-    const optionStart = opts?.binFrom ??
-        opts?.startAddress;
-    const symbolStart = symbols.find((symbol) => symbol.kind === 'constant' && symbol.name === BINFROM_SYMBOL_NAME);
-    const symbolEnd = symbols.find((symbol) => symbol.kind === 'constant' && symbol.name === BINTO_SYMBOL_NAME);
-    const start = optionStart ?? (symbolStart?.kind === 'constant' ? symbolStart.value : writtenStart);
-    const exclusiveEnd = symbolEnd?.kind === 'constant' ? symbolEnd.value + 1 : end;
-    const out = new Uint8Array(Math.max(0, exclusiveEnd - start));
-    for (let i = 0; i < out.length; i++) {
-        const addr = start + i;
-        out[i] = map.bytes.get(addr) ?? 0;
-    }
-    return { kind: 'bin', bytes: out };
-}

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

@@ -1,9 +0,0 @@
-import type { D8mArtifact, EmittedByteMap, SymbolEntry, WriteD8mOptions } from './types.js';
-/**
- * Create a minimal D8 Debug Map (D8M) v1 JSON artifact.
- *
- * Implementation note:
- * - Emits baseline contiguous written segments plus optional source-attributed per-file segments
- *   when provided by lowering.
- */
-export declare function writeD8m(map: EmittedByteMap, symbols: SymbolEntry[], opts?: WriteD8mOptions): D8mArtifact;

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

@@ -1,245 +0,0 @@
-import { isAbsolute, relative, resolve } from 'node:path';
-import { getWrittenRange, getWrittenSegments } from './range.js';
-function normalizeD8mPath(file, rootDir) {
-    const withSlashes = file.replace(/\\/g, '/');
-    if (!rootDir)
-        return withSlashes;
-    const absFile = resolve(file);
-    const absRoot = resolve(rootDir);
-    const rel = relative(absRoot, absFile);
-    if (!rel || rel.startsWith('..') || isAbsolute(rel)) {
-        return absFile.replace(/\\/g, '/');
-    }
-    return rel.replace(/\\/g, '/');
-}
-function normalizeD8mInputs(inputs, rootDir) {
-    if (!inputs)
-        return undefined;
-    const entries = Object.entries(inputs)
-        .filter((entry) => typeof entry[1] === 'string' && entry[1] !== '')
-        .map(([key, value]) => [key, normalizeD8mPath(value, rootDir)]);
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function toSerializedSymbol(symbol) {
-    if (symbol.kind === 'constant') {
-        return {
-            name: symbol.name,
-            kind: 'constant',
-            value: symbol.value,
-            ...(symbol.file !== undefined ? { file: symbol.file } : {}),
-            ...(symbol.line !== undefined ? { line: symbol.line } : {}),
-            ...(symbol.scope !== undefined ? { scope: symbol.scope } : {}),
-        };
-    }
-    return {
-        name: symbol.name,
-        kind: symbol.kind,
-        address: symbol.address,
-        ...(symbol.file !== undefined ? { file: symbol.file } : {}),
-        ...(symbol.line !== undefined ? { line: symbol.line } : {}),
-        ...(symbol.scope !== undefined ? { scope: symbol.scope } : {}),
-        ...(symbol.size !== undefined ? { size: symbol.size } : {}),
-    };
-}
-function compareSerializedSymbols(a, b) {
-    const aClass = a.kind === 'constant' ? 1 : 0;
-    const bClass = b.kind === 'constant' ? 1 : 0;
-    if (aClass !== bClass)
-        return aClass - bClass;
-    const aAddress = a.kind === 'constant' ? a.value & 0xffff : a.address;
-    const bAddress = b.kind === 'constant' ? b.value & 0xffff : b.address;
-    if (aAddress !== bAddress)
-        return aAddress - bAddress;
-    const nameCmp = a.name.toLowerCase().localeCompare(b.name.toLowerCase());
-    if (nameCmp !== 0)
-        return nameCmp;
-    const kindCmp = a.kind.localeCompare(b.kind);
-    if (kindCmp !== 0)
-        return kindCmp;
-    const fileCmp = (a.file ?? '').localeCompare(b.file ?? '');
-    if (fileCmp !== 0)
-        return fileCmp;
-    const lineCmp = (a.line ?? 0) - (b.line ?? 0);
-    if (lineCmp !== 0)
-        return lineCmp;
-    if (a.kind === 'constant' && b.kind === 'constant') {
-        return a.value - b.value;
-    }
-    const aSize = a.size ?? 0;
-    const bSize = b.size ?? 0;
-    return aSize - bSize;
-}
-function compareFileSymbols(a, b) {
-    const withFile = (symbol) => ({
-        ...symbol,
-    });
-    return compareSerializedSymbols(withFile(a), withFile(b));
-}
-function compareD8mSegments(a, b) {
-    if (a.start !== b.start)
-        return a.start - b.start;
-    if (a.end !== b.end)
-        return a.end - b.end;
-    if (a.lstLine !== b.lstLine)
-        return a.lstLine - b.lstLine;
-    const aLine = a.line ?? 0;
-    const bLine = b.line ?? 0;
-    if (aLine !== bLine)
-        return aLine - bLine;
-    const kindCmp = a.kind.localeCompare(b.kind);
-    if (kindCmp !== 0)
-        return kindCmp;
-    return a.confidence.localeCompare(b.confidence);
-}
-function rangesOverlap(a, b) {
-    return a.start < b.end && b.start < a.end;
-}
-function hasOverlappingSourceSegment(sourceSegmentsByFile, file, range) {
-    return (sourceSegmentsByFile.get(file) ?? []).some((segment) => rangesOverlap({ start: segment.start, end: segment.end }, range));
-}
-/**
- * Create a minimal D8 Debug Map (D8M) v1 JSON artifact.
- *
- * Implementation note:
- * - Emits baseline contiguous written segments plus optional source-attributed per-file segments
- *   when provided by lowering.
- */
-export function writeD8m(map, symbols, opts) {
-    const { start, end } = getWrittenRange(map);
-    const writtenSegments = getWrittenSegments(map);
-    const segments = writtenSegments.length > 0
-        ? writtenSegments
-        : start < end
-            ? [{ start, end }]
-            : [{ start: 0, end: 0 }];
-    const normalizedSymbols = symbols.map((s) => ({
-        ...s,
-        ...(s.file !== undefined ? { file: normalizeD8mPath(s.file, opts?.rootDir) } : {}),
-    }));
-    const normalizedSourceSegments = (map.sourceSegments ?? [])
-        .filter((segment) => segment.end > segment.start)
-        .map((segment) => ({
-        ...segment,
-        file: normalizeD8mPath(segment.file, opts?.rootDir),
-    }));
-    const fileSet = new Set(normalizedSymbols
-        .map((s) => s.file)
-        .filter((f) => typeof f === 'string' && f.length > 0));
-    for (const segment of normalizedSourceSegments) {
-        if (segment.file.length > 0)
-            fileSet.add(segment.file);
-    }
-    const fileList = Array.from(fileSet).sort((a, b) => a.localeCompare(b));
-    const serializedSymbols = normalizedSymbols
-        .map(toSerializedSymbol)
-        .sort(compareSerializedSymbols);
-    const fileEntries = new Map();
-    const ensureFileEntry = (path) => {
-        let entry = fileEntries.get(path);
-        if (!entry) {
-            entry = { symbols: [], segments: [] };
-            fileEntries.set(path, entry);
-        }
-        return entry;
-    };
-    for (const symbol of serializedSymbols) {
-        const key = symbol.file ?? '';
-        const entry = ensureFileEntry(key);
-        const { file: _file, ...withoutFile } = symbol;
-        entry.symbols.push(withoutFile);
-    }
-    for (const segment of normalizedSourceSegments) {
-        ensureFileEntry(segment.file).segments.push({
-            start: segment.start,
-            end: segment.end,
-            lstLine: segment.line,
-            line: segment.line,
-            kind: segment.kind,
-            confidence: segment.confidence,
-        });
-    }
-    const sourceSegmentsByFile = new Map();
-    for (const segment of normalizedSourceSegments) {
-        const entries = sourceSegmentsByFile.get(segment.file);
-        if (entries) {
-            entries.push(segment);
-        }
-        else {
-            sourceSegmentsByFile.set(segment.file, [segment]);
-        }
-    }
-    const symbolRangesByFile = new Map();
-    for (const symbol of serializedSymbols) {
-        if (symbol.kind === 'constant' || symbol.file === undefined)
-            continue;
-        const spanSize = symbol.size !== undefined && symbol.size > 0 ? symbol.size : 1;
-        const range = {
-            start: symbol.address,
-            end: Math.min(0x10000, symbol.address + spanSize),
-        };
-        const currentRanges = symbolRangesByFile.get(symbol.file);
-        if (currentRanges) {
-            currentRanges.push(range);
-        }
-        else {
-            symbolRangesByFile.set(symbol.file, [range]);
-        }
-    }
-    for (const ranges of symbolRangesByFile.values()) {
-        ranges.sort((a, b) => a.start - b.start || a.end - b.end);
-    }
-    for (const segment of segments) {
-        const segmentRange = { start: segment.start, end: segment.end };
-        const fileKeys = Array.from(symbolRangesByFile.entries())
-            .filter(([, ranges]) => ranges.some((range) => rangesOverlap(range, segmentRange)))
-            .map(([path]) => path)
-            .sort((a, b) => a.localeCompare(b));
-        const targets = fileKeys.length > 0 ? fileKeys : [fileList[0] ?? ''];
-        for (const target of targets) {
-            if (hasOverlappingSourceSegment(sourceSegmentsByFile, target, segmentRange))
-                continue;
-            ensureFileEntry(target).segments.push({
-                start: segment.start,
-                end: segment.end,
-                // Synthetic file-attribution segments have no exact source line; use a valid fallback.
-                lstLine: 1,
-                kind: 'unknown',
-                confidence: 'low',
-            });
-        }
-    }
-    for (const entry of fileEntries.values()) {
-        entry.symbols.sort(compareFileSymbols);
-        entry.segments.sort(compareD8mSegments);
-    }
-    const files = Object.fromEntries(Array.from(fileEntries.entries())
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([path, entry]) => [
-        path,
-        {
-            ...(entry.segments.length > 0 ? { segments: entry.segments } : {}),
-            ...(entry.symbols.length > 0 ? { symbols: entry.symbols } : {}),
-        },
-    ]));
-    const generatorInputs = normalizeD8mInputs(opts?.inputs, opts?.rootDir);
-    const json = {
-        format: 'd8-debug-map',
-        version: 1,
-        arch: 'z80',
-        addressWidth: 16,
-        endianness: 'little',
-        files,
-        segments,
-        ...(fileList.length > 0 ? { fileList } : {}),
-        symbols: serializedSymbols,
-        generator: {
-            name: 'azm',
-            tool: 'azm',
-            ...(opts?.packageVersion !== undefined ? { version: opts.packageVersion } : {}),
-            ...(generatorInputs !== undefined ? { inputs: generatorInputs } : {}),
-            ...(opts?.entrySymbol !== undefined ? { entrySymbol: opts.entrySymbol } : {}),
-            ...(opts?.entryAddress !== undefined ? { entryAddress: opts.entryAddress & 0xffff } : {}),
-        },
-    };
-    return { kind: 'd8m', json };
-}

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

@@ -1,8 +0,0 @@
-import type { EmittedByteMap, HexArtifact, SymbolEntry, WriteHexOptions } from './types.js';
-/**
- * Create an Intel HEX artifact from an emitted address->byte map.
- *
- * - Emits only type-00 data records and a type-01 EOF record.
- * - Does not emit extended address records (assumes 16-bit address space).
- */
-export declare function writeHex(map: EmittedByteMap, _symbols: SymbolEntry[], opts?: WriteHexOptions): HexArtifact;