@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/lowering/capabilities.d.ts

@@ -1,67 +0,0 @@
-import type { Diagnostic, DiagnosticId } from '../diagnosticTypes.js';
-import type { AsmItemNode, AsmOperandNode, EaExprNode, ImmExprNode, OpDeclNode, SourceSpan } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-import type { OpOverloadSelection } from './opMatching.js';
-export interface LoweringDiagnosticsCapability {
-    /** Mutable diagnostic list. */
-    diagnostics: Diagnostic[];
-    /** Span-attached diagnostic. */
-    diagAt: (diagnostics: Diagnostic[], span: SourceSpan, message: string) => void;
-}
-interface LoweringDiagnosticsWithIdCapability extends LoweringDiagnosticsCapability {
-    /** Diagnostic with stable id. */
-    diagAtWithId: (diagnostics: Diagnostic[], span: SourceSpan, id: DiagnosticId, message: string) => void;
-}
-export interface LoweringDiagnosticsWithSeverityCapability extends LoweringDiagnosticsWithIdCapability {
-    /** Diagnostic with id and severity. */
-    diagAtWithSeverityAndId: (diagnostics: Diagnostic[], span: SourceSpan, id: DiagnosticId, severity: 'warning' | 'error', message: string) => void;
-}
-export interface CompileEnvCapability {
-    /** Compile environment (equates, enums, types). */
-    env: CompileEnv;
-}
-export interface AstCloneCapability {
-    /** Deep-clone an imm AST node. */
-    cloneImmExpr: (expr: ImmExprNode) => ImmExprNode;
-    /** Deep-clone an EA AST node. */
-    cloneEaExpr: (ea: EaExprNode) => EaExprNode;
-    /** Deep-clone an asm operand. */
-    cloneOperand: (operand: AsmOperandNode) => AsmOperandNode;
-}
-export interface DottedEaNameCapability {
-    /** Flattens dotted EA to a single string; `undefined` if not a simple dotted path. */
-    flattenEaDottedName: (ea: EaExprNode) => string | undefined;
-}
-export interface FixedTokenNormalizationCapability {
-    /** Normalizes fixed tokens for op matching; `undefined` if not applicable. */
-    normalizeFixedToken: (operand: AsmOperandNode) => string | undefined;
-}
-export interface InverseConditionCapability {
-    /** Inverts a condition name for opposite branch; `undefined` if unknown. */
-    inverseConditionName: (name: string) => string | undefined;
-}
-export interface HiddenLabelCapability {
-    /** Allocates a unique hidden label with `prefix`. */
-    newHiddenLabel: (prefix: string) => string;
-}
-export interface AsmRangeLoweringCapability {
-    /** Lowers a contiguous asm range until `stopKinds`; returns next index. */
-    lowerAsmRange: (items: readonly AsmItemNode[], startIndex: number, stopKinds: Set<string>) => number;
-}
-export interface FlowSyncCapability {
-    /** Persists structured-control state into the flow ref. */
-    syncToFlow: () => void;
-}
-export interface OpCandidateResolverCapability {
-    /** Resolves op overloads; `undefined` if none. */
-    resolveOpCandidates: (name: string, file: string) => OpDeclNode[] | undefined;
-}
-export interface OpOperandFormattingCapability {
-    /** Renders an operand for diagnostic text. */
-    formatAsmOperandForOpDiag: (operand: AsmOperandNode) => string;
-}
-export interface OpOverloadSelectionCapability {
-    /** Picks overload from operands; returns selection metadata. */
-    selectOpOverload: (overloads: OpDeclNode[], operands: AsmOperandNode[]) => OpOverloadSelection;
-}
-export {};

package/dist/legacy-root-azm/src/lowering/capabilities.js

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

package/dist/legacy-root-azm/src/lowering/eaResolution.d.ts

@@ -1,58 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { EaExprNode, SourceSpan, TypeExprNode } from '../frontend/ast.js';
-import { type CompileEnv } from '../semantics/env.js';
-export type EaResolution = {
-    /** Resolved global/absolute label or numeric base. */
-    kind: 'abs';
-    /** Lowercased symbol name or stringified numeric base for fixups. */
-    baseLower: string;
-    /** Byte offset added to the base symbol. */
-    addend: number;
-    /** Optional inferred type at this address; omit when unknown. */
-    typeExpr?: TypeExprNode;
-};
-/** Maps, env, and type hooks used by {@link createEaResolutionHelpers} — not the full assembler-lowering context. */
-type EAResolutionContext = {
-    /** Compile-time const/enum/type environment for imm evaluation. */
-    env: CompileEnv;
-    /** Mutable diagnostic list for resolution errors. */
-    diagnostics: Diagnostic[];
-    /** Appends a span-attached diagnostic. */
-    diagAt: (diagnostics: Diagnostic[], span: SourceSpan, message: string) => void;
-    /** Evaluates immediates with diagnostics; `undefined` if ill-typed or non-const. */
-    evalImmExpr: (expr: import('../frontend/ast.js').ImmExprNode) => number | undefined;
-    /** Evaluates immediates without recording diagnostics (best-effort). */
-    evalImmNoDiag: (expr: import('../frontend/ast.js').ImmExprNode) => number | undefined;
-    /** Classifies scalar kinds for layout; `undefined` if not a scalar shape. */
-    resolveScalarKind: (typeExpr: TypeExprNode) => 'byte' | 'word' | 'addr' | undefined;
-    /** Unwraps record/union for field walk; `undefined` if not aggregate. */
-    resolveAggregateType: (te: TypeExprNode) => {
-        kind: 'record' | 'union';
-        fields: import('../frontend/ast.js').RecordFieldNode[];
-    } | undefined;
-    /** Infers a type for an EA subexpression when possible; `undefined` if unknown. */
-    resolveEaTypeExpr: (ea: EaExprNode) => TypeExprNode | undefined;
-    /** Layout size in bytes; `undefined` if layout cannot be computed. */
-    sizeOfTypeExpr: (te: TypeExprNode) => number | undefined;
-};
-/** Builds {@link EAResolutionContext} from emit-phase env/workspace plus type-resolution hooks. */
-export declare function buildEaResolutionContext(params: {
-    /** See {@link EAResolutionContext.env}. */
-    env: CompileEnv;
-    /** See {@link EAResolutionContext.diagnostics}. */
-    diagnostics: Diagnostic[];
-    /** See {@link EAResolutionContext.diagAt}. */
-    diagAt: EAResolutionContext['diagAt'];
-    /** See {@link EAResolutionContext.resolveScalarKind}. */
-    resolveScalarKind: EAResolutionContext['resolveScalarKind'];
-    /** See {@link EAResolutionContext.resolveAggregateType}. */
-    resolveAggregateType: EAResolutionContext['resolveAggregateType'];
-    /** See {@link EAResolutionContext.resolveEaTypeExpr}. */
-    resolveEaTypeExpr: EAResolutionContext['resolveEaTypeExpr'];
-    /** See {@link EAResolutionContext.evalImmNoDiag}. */
-    evalImmNoDiag: EAResolutionContext['evalImmNoDiag'];
-}): EAResolutionContext;
-export declare function createEaResolutionHelpers(ctx: EAResolutionContext): {
-    resolveEa: (ea: EaExprNode, span: SourceSpan) => EaResolution | undefined;
-};
-export {};

package/dist/legacy-root-azm/src/lowering/eaResolution.js

@@ -1,159 +0,0 @@
-import { evalImmExpr } from '../semantics/env.js';
-import { sizeOfTypeExpr } from '../semantics/layout.js';
-import { foldLayoutCastAbsEa, isLayoutCastLabelBase } from '../semantics/layoutCastFold.js';
-/** Builds {@link EAResolutionContext} from emit-phase env/workspace plus type-resolution hooks. */
-export function buildEaResolutionContext(params) {
-    const { env, diagnostics, diagAt } = params;
-    return {
-        env,
-        diagnostics,
-        diagAt,
-        evalImmExpr: (expr) => evalImmExpr(expr, env, diagnostics),
-        evalImmNoDiag: params.evalImmNoDiag,
-        resolveScalarKind: params.resolveScalarKind,
-        resolveAggregateType: params.resolveAggregateType,
-        resolveEaTypeExpr: params.resolveEaTypeExpr,
-        sizeOfTypeExpr: (te) => sizeOfTypeExpr(te, env, diagnostics),
-    };
-}
-export function createEaResolutionHelpers(ctx) {
-    const hasKnownType = (typeExpr) => ctx.resolveScalarKind(typeExpr) !== undefined ||
-        ctx.resolveAggregateType(typeExpr) !== undefined ||
-        ctx.sizeOfTypeExpr(typeExpr) !== undefined;
-    const resolveEa = (ea, span) => {
-        const go = (expr) => {
-            const layoutFold = foldLayoutCastAbsEa(expr, {
-                env: ctx.env,
-                evalImm: ctx.evalImmExpr,
-                resolveAbsBase: (baseEa) => {
-                    const baseResolved = go(baseEa);
-                    if (baseResolved?.kind !== 'abs')
-                        return undefined;
-                    return { baseLower: baseResolved.baseLower, addend: baseResolved.addend };
-                },
-                diagnostics: ctx.diagnostics,
-            });
-            if (layoutFold) {
-                return { kind: 'abs', baseLower: layoutFold.baseLower, addend: layoutFold.addend };
-            }
-            switch (expr.kind) {
-                case 'EaName': {
-                    const baseLower = expr.name.toLowerCase();
-                    const constValue = ctx.evalImmNoDiag({
-                        kind: 'ImmName',
-                        span: expr.span,
-                        name: expr.name,
-                    });
-                    if (constValue !== undefined) {
-                        return { kind: 'abs', baseLower: String(constValue), addend: 0 };
-                    }
-                    return { kind: 'abs', baseLower, addend: 0 };
-                }
-                case 'EaImm': {
-                    const value = ctx.evalImmNoDiag(expr.expr);
-                    if (value === undefined)
-                        return undefined;
-                    return { kind: 'abs', baseLower: String(value), addend: 0 };
-                }
-                case 'EaLayoutCast': {
-                    if (!hasKnownType(expr.typeExpr))
-                        return undefined;
-                    if (isLayoutCastLabelBase(expr.base)) {
-                        const baseResolved = go(expr.base);
-                        if (baseResolved?.kind === 'abs') {
-                            return { ...baseResolved, typeExpr: expr.typeExpr };
-                        }
-                        return undefined;
-                    }
-                    return undefined;
-                }
-                case 'EaAdd':
-                case 'EaSub': {
-                    const base = go(expr.base);
-                    if (!base)
-                        return undefined;
-                    const v = ctx.evalImmNoDiag(expr.offset);
-                    if (v === undefined)
-                        return undefined;
-                    const delta = expr.kind === 'EaAdd' ? v : -v;
-                    if (base.kind === 'abs')
-                        return { ...base, addend: base.addend + delta };
-                    return undefined;
-                }
-                case 'EaField': {
-                    const base = go(expr.base);
-                    if (!base)
-                        return undefined;
-                    if (!base.typeExpr) {
-                        ctx.diagAt(ctx.diagnostics, span, `Cannot resolve field "${expr.field}" without layout type information.`);
-                        return undefined;
-                    }
-                    const agg = ctx.resolveAggregateType(base.typeExpr);
-                    if (!agg) {
-                        ctx.diagAt(ctx.diagnostics, span, `Field access ".${expr.field}" requires a record or union type.`);
-                        return undefined;
-                    }
-                    let off = 0;
-                    for (const f of agg.fields) {
-                        if (f.name === expr.field) {
-                            if (base.kind === 'abs') {
-                                return {
-                                    kind: 'abs',
-                                    baseLower: base.baseLower,
-                                    addend: base.addend + off,
-                                    typeExpr: f.typeExpr,
-                                };
-                            }
-                            return undefined;
-                        }
-                        if (agg.kind === 'record') {
-                            const sz = sizeOfTypeExpr(f.typeExpr, ctx.env, ctx.diagnostics);
-                            if (sz === undefined)
-                                return undefined;
-                            off += sz;
-                        }
-                    }
-                    const kind = agg.kind === 'union' ? 'union' : 'record';
-                    ctx.diagAt(ctx.diagnostics, span, `Unknown ${kind} field "${expr.field}".`);
-                    return undefined;
-                }
-                case 'EaIndex': {
-                    const base = go(expr.base);
-                    if (!base)
-                        return undefined;
-                    if (!base.typeExpr) {
-                        ctx.diagAt(ctx.diagnostics, span, `Cannot resolve indexing without layout type information.`);
-                        return undefined;
-                    }
-                    if (base.typeExpr.kind !== 'ArrayType') {
-                        ctx.diagAt(ctx.diagnostics, span, `Indexing requires an array type.`);
-                        return undefined;
-                    }
-                    const elemSize = ctx.sizeOfTypeExpr(base.typeExpr.element);
-                    if (elemSize === undefined)
-                        return undefined;
-                    if (expr.index.kind === 'IndexImm') {
-                        const idx = ctx.evalImmExpr(expr.index.value);
-                        if (idx === undefined)
-                            return undefined;
-                        const delta = idx * elemSize;
-                        if (base.kind === 'abs') {
-                            return {
-                                kind: 'abs',
-                                baseLower: base.baseLower,
-                                addend: base.addend + delta,
-                                typeExpr: base.typeExpr.element,
-                            };
-                        }
-                        return undefined;
-                    }
-                    return undefined;
-                }
-            }
-        };
-        return go(ea);
-    };
-    return {
-        resolveEa,
-    };
-}

package/dist/legacy-root-azm/src/lowering/emissionCore.d.ts

@@ -1,17 +0,0 @@
-type EmissionCoreContext = {
-    /** Current code emission offset. */
-    getCodeOffset: () => number;
-    /** Sets absolute code offset cursor. */
-    setCodeOffset: (value: number) => void;
-    /** Writes one byte into the code map. */
-    setCodeByte: (offset: number, value: number) => void;
-    /** Extends source range map for listings. */
-    recordCodeSourceRange: (start: number, end: number) => void;
-    /** Optional trace hook for emitted bytes. */
-    traceInstruction: (start: number, bytes: Uint8Array, traceText: string) => void;
-};
-export declare function createEmissionCoreHelpers(ctx: EmissionCoreContext): {
-    emitCodeBytes: (bs: Uint8Array, _file: string) => number;
-    emitRawCodeBytes: (bs: Uint8Array, _file: string, traceText: string) => void;
-};
-export {};

package/dist/legacy-root-azm/src/lowering/emissionCore.js

@@ -1,21 +0,0 @@
-export function createEmissionCoreHelpers(ctx) {
-    const emitCodeBytes = (bs, _file) => {
-        const start = ctx.getCodeOffset();
-        let codeOffset = start;
-        for (const b of bs) {
-            ctx.setCodeByte(codeOffset, b);
-            codeOffset++;
-        }
-        ctx.setCodeOffset(codeOffset);
-        ctx.recordCodeSourceRange(start, codeOffset);
-        return start;
-    };
-    const emitRawCodeBytes = (bs, _file, traceText) => {
-        const start = emitCodeBytes(bs, _file);
-        ctx.traceInstruction(start, bs, traceText);
-    };
-    return {
-        emitCodeBytes,
-        emitRawCodeBytes,
-    };
-}

package/dist/legacy-root-azm/src/lowering/emit.d.ts

@@ -1,17 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { ProgramNode } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-import { type EmitProgramOptions, type EmitProgramResult } from './emitPipeline.js';
-/**
- * Emit machine-code bytes for a parsed program into an address->byte map.
- *
- * Orchestration follows the phased pipeline in `emitPipeline.ts`. Phase 1 (workspace wiring)
- * is implemented in this file; phases 2–4 use `runEmitPrescanPhase`, `runEmitLoweringPhase`,
- * and `runEmitPlacementAndArtifactPhase`.
- *
- * Implementation notes:
- * - Uses code and data byte maps while lowering, then merges them during placement.
- * - `.org` and `.align` move the current assembler placement.
- * - Detects overlapping byte emissions across the final address map.
- */
-export declare function emitProgram(program: ProgramNode, env: CompileEnv, diagnostics: Diagnostic[], options?: EmitProgramOptions): EmitProgramResult;

package/dist/legacy-root-azm/src/lowering/emit.js

@@ -1,46 +0,0 @@
-import { emitProgramEmptyResult, mergeEmitFinalizationContext, runEmitLoweringPhase, runEmitPlacementAndArtifactPhase, runEmitPrescanPhase, } from './emitPipeline.js';
-import { diag } from './loweringDiagnostics.js';
-import { createEmitPhase1Workspace } from './emitPhase1Workspace.js';
-import { createEmitPhase1Helpers } from './emitPhase1Helpers.js';
-import { buildEmitFinalizationPhaseEnv } from './emitFinalizationSetup.js';
-/**
- * Emit machine-code bytes for a parsed program into an address->byte map.
- *
- * Orchestration follows the phased pipeline in `emitPipeline.ts`. Phase 1 (workspace wiring)
- * is implemented in this file; phases 2–4 use `runEmitPrescanPhase`, `runEmitLoweringPhase`,
- * and `runEmitPlacementAndArtifactPhase`.
- *
- * Implementation notes:
- * - Uses code and data byte maps while lowering, then merges them during placement.
- * - `.org` and `.align` move the current assembler placement.
- * - Detects overlapping byte emissions across the final address map.
- */
-export function emitProgram(program, env, diagnostics, options) {
-    const firstSourceFile = program.files[0];
-    if (!firstSourceFile) {
-        diag(diagnostics, program.entryFile, 'No source files to compile.');
-        return emitProgramEmptyResult();
-    }
-    const workspace = createEmitPhase1Workspace(program, env, options);
-    const phase1 = createEmitPhase1Helpers({
-        program,
-        env,
-        diagnostics,
-        workspace,
-        ...(options !== undefined ? { options } : {}),
-    });
-    // --- Phase 2: prescan (op registry / alias metadata) ---
-    const prescan = runEmitPrescanPhase(phase1.programLoweringContext);
-    // --- Phase 3: lowering (bytes + fixup queues) ---
-    const lowered = runEmitLoweringPhase(phase1.programLoweringContext, prescan);
-    phase1.flushTrailingUserComments();
-    // --- Phase 4: placement, fixup resolution, merged `EmittedByteMap` ---
-    const finalized = runEmitPlacementAndArtifactPhase(mergeEmitFinalizationContext(lowered, buildEmitFinalizationPhaseEnv({
-        env,
-        diagnostics,
-        workspace,
-        helpers: phase1,
-        ...(options !== undefined ? { options } : {}),
-    })));
-    return { ...finalized, loweredAsmStream: phase1.loweredAsmStream };
-}

package/dist/legacy-root-azm/src/lowering/emitContextBuilder.d.ts

@@ -1,63 +0,0 @@
-/**
- * Emit ↔ lowering context wiring (#1084, #1316)
- *
- * Assembler-lowering state is passed as {@link import('./assemblerLoweringContext.js').AssemblerLoweringComponentContexts}
- * — named slices that merge into {@link import('./assemblerLoweringContext.js').AssemblerLoweringSharedContext}.
- * Program-level fields stay on {@link EmitProgramLoweringContextInputs}.
- */
-import type { AssemblerLoweringComponentContexts, AssemblerLoweringSharedContext, AssemblerLoweringSymbolContext } from './assemblerLoweringContext.js';
-import type { Context as ProgramLoweringContext } from './programLowering.js';
-/**
- * Program-level fields merged with shared assembler-lowering hooks.
- */
-export type EmitProgramLoweringContextInputs = {
-    /** @inheritdoc ProgramLoweringContext */
-    program: ProgramLoweringContext['program'];
-    /** @inheritdoc ProgramLoweringContext */
-    includeDirs: ProgramLoweringContext['includeDirs'];
-    /** @inheritdoc ProgramLoweringContext */
-    localOpsByFile: ProgramLoweringContext['localOpsByFile'];
-    /** @inheritdoc ProgramLoweringContext */
-    declaredOpNames: ProgramLoweringContext['declaredOpNames'];
-    /** @inheritdoc ProgramLoweringContext */
-    absoluteSymbols: ProgramLoweringContext['absoluteSymbols'];
-    /** @inheritdoc ProgramLoweringContext */
-    symbols: ProgramLoweringContext['symbols'];
-    /** @inheritdoc ProgramLoweringContext */
-    dataBytes: ProgramLoweringContext['dataBytes'];
-    /** @inheritdoc ProgramLoweringContext */
-    codeBytes: ProgramLoweringContext['codeBytes'];
-    /** @inheritdoc ProgramLoweringContext */
-    activePlacementRef: ProgramLoweringContext['activePlacementRef'];
-    /** @inheritdoc ProgramLoweringContext */
-    codeOffsetRef: ProgramLoweringContext['codeOffsetRef'];
-    /** @inheritdoc ProgramLoweringContext */
-    dataOffsetRef: ProgramLoweringContext['dataOffsetRef'];
-    /** @inheritdoc ProgramLoweringContext */
-    baseExprs: ProgramLoweringContext['baseExprs'];
-    /** @inheritdoc ProgramLoweringContext */
-    advanceAlign: ProgramLoweringContext['advanceAlign'];
-    /** @inheritdoc ProgramLoweringContext */
-    alignTo: ProgramLoweringContext['alignTo'];
-    /** @inheritdoc ProgramLoweringContext */
-    loadBinInput: ProgramLoweringContext['loadBinInput'];
-    /** @inheritdoc ProgramLoweringContext */
-    resolveAggregateType: ProgramLoweringContext['resolveAggregateType'];
-    /** @inheritdoc ProgramLoweringContext */
-    sizeOfTypeExpr: ProgramLoweringContext['sizeOfTypeExpr'];
-    /** @inheritdoc ProgramLoweringContext */
-    recordLoweredAsmItem: ProgramLoweringContext['recordLoweredAsmItem'];
-    /** @inheritdoc ProgramLoweringContext */
-    lowerImmExprForLoweredAsm: ProgramLoweringContext['lowerImmExprForLoweredAsm'];
-    /** @inheritdoc AssemblerLoweringSymbolContext */
-    currentCodeSegmentTagRef: AssemblerLoweringSymbolContext['currentCodeSegmentTagRef'];
-};
-export type EmitLoweringContextBuilderInput = {
-    /** Named assembler-lowering slices (merge to {@link AssemblerLoweringSharedContext}). */
-    readonly assemblerLowering: Readonly<AssemblerLoweringComponentContexts>;
-    readonly programLowering: Readonly<EmitProgramLoweringContextInputs>;
-};
-export declare function createEmitLoweringContexts(input: EmitLoweringContextBuilderInput): {
-    assemblerLoweringSharedContext: AssemblerLoweringSharedContext;
-    programLoweringContext: ProgramLoweringContext;
-};

package/dist/legacy-root-azm/src/lowering/emitContextBuilder.js

@@ -1,41 +0,0 @@
-/**
- * Emit ↔ lowering context wiring (#1084, #1316)
- *
- * Assembler-lowering state is passed as {@link import('./assemblerLoweringContext.js').AssemblerLoweringComponentContexts}
- * — named slices that merge into {@link import('./assemblerLoweringContext.js').AssemblerLoweringSharedContext}.
- * Program-level fields stay on {@link EmitProgramLoweringContextInputs}.
- */
-import { mergeAssemblerLoweringSharedContext } from './assemblerLoweringContext.js';
-const createAssemblerLoweringSharedContext = mergeAssemblerLoweringSharedContext;
-function createProgramLoweringContext(shared, input) {
-    return {
-        ...shared,
-        program: input.program,
-        includeDirs: input.includeDirs,
-        localOpsByFile: input.localOpsByFile,
-        declaredOpNames: input.declaredOpNames,
-        absoluteSymbols: input.absoluteSymbols,
-        symbols: input.symbols,
-        dataBytes: input.dataBytes,
-        codeBytes: input.codeBytes,
-        activePlacementRef: input.activePlacementRef,
-        codeOffsetRef: input.codeOffsetRef,
-        dataOffsetRef: input.dataOffsetRef,
-        baseExprs: input.baseExprs,
-        advanceAlign: input.advanceAlign,
-        alignTo: input.alignTo,
-        loadBinInput: input.loadBinInput,
-        resolveAggregateType: input.resolveAggregateType,
-        sizeOfTypeExpr: input.sizeOfTypeExpr,
-        recordLoweredAsmItem: input.recordLoweredAsmItem,
-        lowerImmExprForLoweredAsm: input.lowerImmExprForLoweredAsm,
-    };
-}
-export function createEmitLoweringContexts(input) {
-    const assemblerLoweringSharedContext = createAssemblerLoweringSharedContext(input.assemblerLowering);
-    const programLoweringContext = createProgramLoweringContext(assemblerLoweringSharedContext, input.programLowering);
-    return {
-        assemblerLoweringSharedContext,
-        programLoweringContext,
-    };
-}

package/dist/legacy-root-azm/src/lowering/emitFinalization.d.ts

@@ -1,61 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { EmittedByteMap, EmittedSourceSegment, SymbolEntry } from '../formats/types.js';
-import type { SourceSpan } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-import { type ProgramEmissionFinalizeContext } from './programLowering.js';
-import type { LoweredAsmProgram, LoweredAsmStream } from './loweredAsmTypes.js';
-export type EmitFinalizationContext = {
-    /** Mutable diagnostics for placement and emission. */
-    diagnostics: Diagnostic[];
-    /** File-scoped diagnostic helper. */
-    diag: (diagnostics: Diagnostic[], file: string, message: string) => void;
-    /** Span-scoped diagnostic helper. */
-    diagAt: (diagnostics: Diagnostic[], span: SourceSpan, message: string) => void;
-    /** Entry file path for diagnostics. */
-    primaryFile: string;
-    /** Optional placement base expressions. */
-    baseExprs: ProgramEmissionFinalizeContext['baseExprs'];
-    /** Imm evaluator for bases and fixups. */
-    evalImmExpr: ProgramEmissionFinalizeContext['evalImmExpr'];
-    /** Compile environment. */
-    env: CompileEnv;
-    /** Lowered asm stream before placement. */
-    loweredAsmStream: LoweredAsmStream;
-    /** Current code-placement size cursor after lowering. */
-    codeOffset: number;
-    /** Current data-placement size cursor. */
-    dataOffset: number;
-    /** Pending forward symbols from lowering. */
-    pending: ProgramEmissionFinalizeContext['pending'];
-    /** Symbol table. */
-    symbols: SymbolEntry[];
-    /** Absolute symbols from lowering. */
-    absoluteSymbols: ProgramEmissionFinalizeContext['absoluteSymbols'];
-    /** Absolute fixup queue. */
-    fixups: ProgramEmissionFinalizeContext['fixups'];
-    /** Relative fixup queue. */
-    rel8Fixups: ProgramEmissionFinalizeContext['rel8Fixups'];
-    /** Code-placement bytes. */
-    codeBytes: ProgramEmissionFinalizeContext['codeBytes'];
-    /** Data-placement bytes. */
-    dataBytes: ProgramEmissionFinalizeContext['dataBytes'];
-    /** Merged working byte map. */
-    bytes: Map<number, number>;
-    /** Code source segment map for listings. */
-    codeSourceSegments: EmittedSourceSegment[];
-    /** Align helper. */
-    alignTo: ProgramEmissionFinalizeContext['alignTo'];
-    /** Writes a byte-offset range into `bytes`. */
-    writeBytePlacement: ProgramEmissionFinalizeContext['writeBytePlacement'];
-    /** Computes min/max written for overlap detection. */
-    computeWrittenRange: ProgramEmissionFinalizeContext['computeWrittenRange'];
-    /** Rebases source segments after moves. */
-    rebaseCodeSourceSegments: ProgramEmissionFinalizeContext['rebaseCodeSourceSegments'];
-    /** Optional default code base when not inferred. */
-    defaultCodeBase?: number;
-};
-export declare function finalizeEmitProgram(context: EmitFinalizationContext): {
-    map: EmittedByteMap;
-    symbols: SymbolEntry[];
-    placedLoweredAsmProgram: LoweredAsmProgram;
-};

package/dist/legacy-root-azm/src/lowering/emitFinalization.js

@@ -1,66 +0,0 @@
-import { finalizeProgramEmission } from './programLowering.js';
-import { computePlacementBases } from './programLoweringFinalize.js';
-import { placeLoweredAsmStream } from './loweredAsmPlacement.js';
-import { emitLoweredAsmProgramBytes, syncLoweredAsmInstructionBytesFromFinalBytes, } from './loweredAsmByteEmission.js';
-export function finalizeEmitProgram(context) {
-    const { codeBase, dataBase } = computePlacementBases({
-        baseExprs: context.baseExprs,
-        evalImmExpr: context.evalImmExpr,
-        env: context.env,
-        diagnostics: context.diagnostics,
-        diag: context.diag,
-        primaryFile: context.primaryFile,
-        alignTo: context.alignTo,
-        codeOffset: context.codeOffset,
-        dataOffset: context.dataOffset,
-    }, context.defaultCodeBase, { quiet: true });
-    const placedProgram = placeLoweredAsmStream(context.loweredAsmStream, {
-        diagnostics: context.diagnostics,
-        diag: context.diag,
-        primaryFile: context.primaryFile,
-        baseAddresses: { codeBase, dataBase },
-    });
-    const emission = emitLoweredAsmProgramBytes(placedProgram, {
-        diagnostics: context.diagnostics,
-        diag: context.diag,
-        primaryFile: context.primaryFile,
-        env: context.env,
-    });
-    const mergedCodeBytes = new Map([...context.codeBytes, ...emission.codeBytes]);
-    const mergedDataBytes = new Map([...context.dataBytes, ...emission.dataBytes]);
-    const { writtenRange, sourceSegments } = finalizeProgramEmission({
-        diagnostics: context.diagnostics,
-        diag: context.diag,
-        primaryFile: context.primaryFile,
-        baseExprs: context.baseExprs,
-        evalImmExpr: context.evalImmExpr,
-        env: context.env,
-        codeOffset: context.codeOffset,
-        dataOffset: context.dataOffset,
-        pending: context.pending,
-        symbols: context.symbols,
-        absoluteSymbols: context.absoluteSymbols,
-        fixups: context.fixups,
-        rel8Fixups: context.rel8Fixups,
-        codeBytes: mergedCodeBytes,
-        dataBytes: mergedDataBytes,
-        bytes: context.bytes,
-        codeSourceSegments: context.codeSourceSegments,
-        alignTo: context.alignTo,
-        writeBytePlacement: context.writeBytePlacement,
-        computeWrittenRange: context.computeWrittenRange,
-        rebaseCodeSourceSegments: context.rebaseCodeSourceSegments,
-        ...(context.defaultCodeBase !== undefined ? { defaultCodeBase: context.defaultCodeBase } : {}),
-    });
-    syncLoweredAsmInstructionBytesFromFinalBytes(placedProgram, context.bytes, context.env);
-    const mergedSourceSegments = [...sourceSegments].sort((a, b) => a.start === b.start ? a.end - b.end : a.start - b.start);
-    return {
-        map: {
-            bytes: context.bytes,
-            writtenRange,
-            ...(mergedSourceSegments.length > 0 ? { sourceSegments: mergedSourceSegments } : {}),
-        },
-        symbols: context.symbols,
-        placedLoweredAsmProgram: placedProgram,
-    };
-}

package/dist/legacy-root-azm/src/lowering/emitFinalizationSetup.d.ts

@@ -1,19 +0,0 @@
-import type { EmitProgramOptions, EmitFinalizationEnv } from './emitPipeline.js';
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { CompileEnv } from '../semantics/env.js';
-import type { EmitPhase1Workspace } from './emitPhase1Workspace.js';
-import type { EmitPhase1Helpers } from './emitPhase1Helpers.js';
-type EmitFinalizationSetupContext = {
-    /** Semantic environment for imm evaluation during finalization. */
-    env: CompileEnv;
-    /** Mutable diagnostic sink for placement and fixup phases. */
-    diagnostics: Diagnostic[];
-    /** Optional emit knobs (code base, etc.); omit when defaults apply. */
-    options?: EmitProgramOptions;
-    /** Phase-1 workspace carrying bytes, fixups, and lowered asm stream. */
-    workspace: EmitPhase1Workspace;
-    /** Phase-1 helpers wired into finalization. */
-    helpers: EmitPhase1Helpers;
-};
-export declare function buildEmitFinalizationPhaseEnv(ctx: EmitFinalizationSetupContext): EmitFinalizationEnv;
-export {};