@jhlagado/azm 0.1.0

package/dist/src/semantics/layout.js

@@ -0,0 +1,226 @@
+import { DiagnosticIds } from '../diagnosticTypes.js';
+function scalarSize(name) {
+    switch (name) {
+        case 'byte':
+            return 1;
+        case 'word':
+        case 'addr':
+            return 2;
+        default:
+            return undefined;
+    }
+}
+function reportTypeError(diagnostics) {
+    return (file, message) => {
+        diagnostics?.push({ id: DiagnosticIds.TypeError, severity: 'error', message, file });
+    };
+}
+function reportMissingArrayLength(te, diag) {
+    diag(te.span.file, `Array length is required here; write T[N].`);
+}
+function resolveNamedType(te, env, visiting, diag, onResolve) {
+    const s = scalarSize(te.name);
+    if (s !== undefined)
+        return onResolve({ kind: 'Scalar', name: te.name, size: s });
+    if (visiting.has(te.name)) {
+        diag(te.span.file, `Recursive type definition detected for "${te.name}".`);
+        return undefined;
+    }
+    const decl = env.types.get(te.name);
+    if (!decl) {
+        diag(te.span.file, `Unknown type "${te.name}".`);
+        return undefined;
+    }
+    visiting.add(te.name);
+    try {
+        return onResolve({ kind: 'Decl', decl });
+    }
+    finally {
+        visiting.delete(te.name);
+    }
+}
+function sumFieldSizes(fields, resolveTypeExpr) {
+    let sum = 0;
+    for (const f of fields) {
+        const fs = resolveTypeExpr(f.typeExpr);
+        if (!fs)
+            return undefined;
+        sum += fs.size;
+    }
+    return { size: sum };
+}
+function maxFieldSize(fields, resolveTypeExpr) {
+    let maxLayout = 0;
+    for (const f of fields) {
+        const fs = resolveTypeExpr(f.typeExpr);
+        if (!fs)
+            return undefined;
+        if (fs.size > maxLayout)
+            maxLayout = fs.size;
+    }
+    return { size: maxLayout };
+}
+function typeLayoutInfoForDecl(decl, resolveTypeExpr) {
+    if (decl.kind === 'UnionDecl') {
+        return maxFieldSize(decl.fields, resolveTypeExpr);
+    }
+    const te = decl.typeExpr;
+    if (te.kind === 'RecordType') {
+        return sumFieldSizes(te.fields, resolveTypeExpr);
+    }
+    return resolveTypeExpr(te);
+}
+export function layoutInfoForTypeExpr(typeExpr, env, diagnostics) {
+    const visiting = new Set();
+    const memo = new Map();
+    const diag = reportTypeError(diagnostics);
+    const sizeOf = (te) => {
+        switch (te.kind) {
+            case 'TypeName': {
+                const cached = memo.get(te.name);
+                if (cached !== undefined)
+                    return cached;
+                return resolveNamedType(te, env, visiting, diag, (resolved) => {
+                    if (resolved.kind === 'Scalar') {
+                        return { size: resolved.size };
+                    }
+                    const info = typeLayoutInfoForDecl(resolved.decl, sizeOf);
+                    if (info)
+                        memo.set(te.name, info);
+                    return info;
+                });
+            }
+            case 'ArrayType': {
+                const es = sizeOf(te.element);
+                if (!es)
+                    return undefined;
+                if (te.length === undefined) {
+                    reportMissingArrayLength(te, diag);
+                    return undefined;
+                }
+                return { size: es.size * te.length };
+            }
+            case 'RecordType':
+                return sumFieldSizes(te.fields, sizeOf);
+        }
+    };
+    return sizeOf(typeExpr);
+}
+/**
+ * Compute the exact semantic size in bytes of a type expression.
+ */
+export function sizeOfTypeExpr(typeExpr, env, diagnostics) {
+    const info = layoutInfoForTypeExpr(typeExpr, env, diagnostics);
+    return info?.size;
+}
+/**
+ * Compute the byte offset of a field path inside a type expression.
+ *
+ * Rules:
+ * - Record fields contribute exact sizes of preceding fields.
+ * - Union field offsets are always 0.
+ * - Array indices must be compile-time constants and contribute index * element exact size.
+ */
+export function offsetPathInTypeExpr(typeExpr, path, env, evalImm, diagnostics) {
+    const diag = reportTypeError(diagnostics);
+    const resolveType = (te, visiting = new Set()) => {
+        switch (te.kind) {
+            case 'TypeName':
+                return resolveNamedType(te, env, visiting, diag, (resolved) => {
+                    if (resolved.kind === 'Scalar')
+                        return { kind: 'Scalar', name: resolved.name };
+                    if (resolved.decl.kind === 'UnionDecl')
+                        return { kind: 'Union', fields: resolved.decl.fields };
+                    return resolveType(resolved.decl.typeExpr, visiting);
+                });
+            case 'ArrayType': {
+                if (te.length === undefined) {
+                    reportMissingArrayLength(te, diag);
+                    return undefined;
+                }
+                return { kind: 'Array', element: te.element, length: te.length };
+            }
+            case 'RecordType':
+                return { kind: 'Record', fields: te.fields };
+        }
+    };
+    const findField = (fields, fieldName, file) => {
+        let offsetBefore = 0;
+        for (const f of fields) {
+            if (f.name === fieldName)
+                return { field: f, offsetBefore };
+            const fs = sizeOfTypeExpr(f.typeExpr, env, diagnostics);
+            if (fs === undefined)
+                return undefined;
+            offsetBefore += fs;
+        }
+        diag(file, `Unknown field "${fieldName}".`);
+        return undefined;
+    };
+    const initial = resolveType(typeExpr);
+    if (!initial)
+        return undefined;
+    let cur = initial;
+    let total = 0;
+    const file = path.span.file;
+    const selectField = (name) => {
+        if (cur.kind === 'Record') {
+            const found = findField(cur.fields, name, file);
+            if (!found)
+                return false;
+            total += found.offsetBefore;
+            const next = resolveType(found.field.typeExpr);
+            if (!next)
+                return false;
+            cur = next;
+            return true;
+        }
+        if (cur.kind === 'Union') {
+            const found = findField(cur.fields, name, file);
+            if (!found)
+                return false;
+            const next = resolveType(found.field.typeExpr);
+            if (!next)
+                return false;
+            cur = next;
+            return true;
+        }
+        diag(file, `Cannot select field "${name}" from non-record/union type.`);
+        return false;
+    };
+    if (path.base !== undefined && !selectField(path.base))
+        return undefined;
+    for (const step of path.steps) {
+        if (step.kind === 'OffsetField') {
+            if (!selectField(step.name))
+                return undefined;
+            continue;
+        }
+        if (cur.kind !== 'Array') {
+            diag(file, `Cannot index into non-array type in offset path.`);
+            return undefined;
+        }
+        const idx = evalImm(step.expr);
+        if (idx === undefined) {
+            diag(file, `Failed to evaluate offset index expression.`);
+            return undefined;
+        }
+        if (!Number.isInteger(idx)) {
+            diag(file, `offset index must evaluate to an integer.`);
+            return undefined;
+        }
+        if (idx < 0 || idx >= cur.length) {
+            diag(file, `offset index ${idx} out of bounds for length ${cur.length}.`);
+            return undefined;
+        }
+        const elemSize = sizeOfTypeExpr(cur.element, env, diagnostics);
+        if (elemSize === undefined)
+            return undefined;
+        total += idx * elemSize;
+        const next = resolveType(cur.element);
+        if (!next)
+            return undefined;
+        cur = next;
+    }
+    return total;
+}

package/dist/src/semantics/layoutCastFold.d.ts

@@ -0,0 +1,22 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { EaExprNode, ImmExprNode, SourceSpan } from '../frontend/ast.js';
+import type { CompileEnv } from './env.js';
+type LayoutCastAbsFold = {
+    baseLower: string;
+    addend: number;
+};
+export declare function isConstantLayoutCastEa(ea: EaExprNode): boolean;
+/** Label or label +/- imm base for `<Type>base[path]`. */
+export declare function isLayoutCastLabelBase(ea: EaExprNode): boolean;
+/**
+ * Fold `<Type>label[path]` to a label fixup addend when the cast uses a label base
+ * and compile-time indexes only.
+ */
+export declare function foldLayoutCastAbsEa(ea: EaExprNode, params: {
+    env: CompileEnv;
+    evalImm: (expr: ImmExprNode) => number | undefined;
+    resolveAbsBase: (baseEa: EaExprNode) => LayoutCastAbsFold | undefined;
+    diagnostics?: Diagnostic[];
+}): LayoutCastAbsFold | undefined;
+export declare function diagLayoutCastRuntimeIndex(diagnostics: Diagnostic[], span: SourceSpan, ea: EaExprNode): boolean;
+export {};

package/dist/src/semantics/layoutCastFold.js

@@ -0,0 +1,118 @@
+import { DiagnosticIds } from '../diagnosticTypes.js';
+import { ALL_REGISTER_NAMES } from '../frontend/grammarData.js';
+import { offsetPathInTypeExpr } from './layout.js';
+function containsLayoutCast(ea) {
+    switch (ea.kind) {
+        case 'EaName':
+        case 'EaImm':
+            return false;
+        case 'EaLayoutCast':
+            return true;
+        case 'EaField':
+        case 'EaAdd':
+        case 'EaSub':
+        case 'EaIndex':
+            return containsLayoutCast(ea.base);
+    }
+}
+function hasRuntimeIndexInLayoutCast(ea) {
+    switch (ea.kind) {
+        case 'EaName':
+        case 'EaImm':
+            return false;
+        case 'EaLayoutCast':
+            return hasRuntimeIndexInLayoutCast(ea.base);
+        case 'EaField':
+        case 'EaAdd':
+        case 'EaSub':
+            return hasRuntimeIndexInLayoutCast(ea.base);
+        case 'EaIndex':
+            if (containsLayoutCast(ea.base) &&
+                (ea.index.kind === 'IndexReg8' ||
+                    ea.index.kind === 'IndexReg16' ||
+                    ea.index.kind === 'IndexMemHL' ||
+                    ea.index.kind === 'IndexMemIxIy' ||
+                    ea.index.kind === 'IndexEa')) {
+                return true;
+            }
+            return hasRuntimeIndexInLayoutCast(ea.base);
+    }
+}
+export function isConstantLayoutCastEa(ea) {
+    return containsLayoutCast(ea) && !hasRuntimeIndexInLayoutCast(ea);
+}
+/** Label or label +/- imm base for `<Type>base[path]`. */
+export function isLayoutCastLabelBase(ea) {
+    switch (ea.kind) {
+        case 'EaName': {
+            if (ALL_REGISTER_NAMES.has(ea.name.toUpperCase()))
+                return false;
+            return true;
+        }
+        case 'EaAdd':
+        case 'EaSub':
+            return isLayoutCastLabelBase(ea.base);
+        default:
+            return false;
+    }
+}
+function decomposeLayoutCastEa(ea) {
+    const steps = [];
+    let cur = ea;
+    while (cur.kind === 'EaField' || cur.kind === 'EaIndex') {
+        if (cur.kind === 'EaField') {
+            steps.unshift({ kind: 'OffsetField', span: cur.span, name: cur.field });
+            cur = cur.base;
+            continue;
+        }
+        if (cur.index.kind !== 'IndexImm')
+            return undefined;
+        steps.unshift({ kind: 'OffsetIndex', span: cur.span, expr: cur.index.value });
+        cur = cur.base;
+    }
+    if (cur.kind !== 'EaLayoutCast')
+        return undefined;
+    return {
+        cast: cur,
+        path: { kind: 'OffsetPath', span: cur.span, steps },
+    };
+}
+/**
+ * Fold `<Type>label[path]` to a label fixup addend when the cast uses a label base
+ * and compile-time indexes only.
+ */
+export function foldLayoutCastAbsEa(ea, params) {
+    if (!isConstantLayoutCastEa(ea))
+        return undefined;
+    const decomposed = decomposeLayoutCastEa(ea);
+    if (!decomposed)
+        return undefined;
+    if (!isLayoutCastLabelBase(decomposed.cast.base))
+        return undefined;
+    const pathOffset = offsetPathInTypeExpr(decomposed.cast.typeExpr, decomposed.path, params.env, params.evalImm, params.diagnostics);
+    if (pathOffset === undefined)
+        return undefined;
+    const base = params.resolveAbsBase(decomposed.cast.base);
+    if (!base)
+        return undefined;
+    return {
+        baseLower: base.baseLower,
+        addend: (base.addend + pathOffset) & 0xffff,
+    };
+}
+function layoutCastRuntimeIndexMessage() {
+    return `Layout-cast address expressions require compile-time constant indexes; runtime index registers require explicit address arithmetic with sizeof/offset constants.`;
+}
+export function diagLayoutCastRuntimeIndex(diagnostics, span, ea) {
+    if (!hasRuntimeIndexInLayoutCast(ea))
+        return false;
+    diagnostics.push({
+        id: DiagnosticIds.TypeError,
+        severity: 'error',
+        message: layoutCastRuntimeIndexMessage(),
+        file: span.file,
+        line: span.start.line,
+        column: span.start.column,
+    });
+    return true;
+}

package/dist/src/semantics/semanticsDiagnostics.d.ts

@@ -0,0 +1,2 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+export declare function diagSemanticsError(diagnostics: Diagnostic[], file: string, message: string): void;

package/dist/src/semantics/semanticsDiagnostics.js

@@ -0,0 +1,4 @@
+import { DiagnosticIds } from '../diagnosticTypes.js';
+export function diagSemanticsError(diagnostics, file, message) {
+    diagnostics.push({ id: DiagnosticIds.SemanticsError, severity: 'error', message, file });
+}

package/dist/src/semantics/typeQueries.d.ts

@@ -0,0 +1,31 @@
+/**
+ * typeQueries.ts — semantic-layer type-resolution helpers.
+ *
+ * These helpers are purely semantic: they walk type expressions and EA paths
+ * using the compile environment and explicit layout casts, but they know
+ * nothing about placed/lowered program state or code-generation concerns.
+ *
+ * The lowering layer imports these helpers directly.
+ */
+import type { EaExprNode, RecordFieldNode, TypeExprNode } from '../frontend/ast.js';
+import type { CompileEnv } from './env.js';
+export type ScalarKind = 'byte' | 'word' | 'addr';
+export type AggregateType = {
+    kind: 'record' | 'union';
+    fields: RecordFieldNode[];
+};
+type TypeResolutionContext = {
+    env: CompileEnv;
+};
+export declare function createTypeResolutionHelpers(ctx: TypeResolutionContext): {
+    resolveScalarKind: (typeExpr: TypeExprNode) => ScalarKind | undefined;
+    resolveAggregateType: (te: TypeExprNode) => AggregateType | undefined;
+    resolveArrayType: (te: TypeExprNode) => {
+        element: TypeExprNode;
+        length?: number;
+    } | undefined;
+    resolveEaTypeExpr: (ea: EaExprNode) => TypeExprNode | undefined;
+    sameTypeShape: (left: TypeExprNode, right: TypeExprNode) => boolean;
+    typeDisplay: (te: TypeExprNode) => string;
+};
+export {};

package/dist/src/semantics/typeQueries.js

@@ -0,0 +1,124 @@
+/**
+ * typeQueries.ts — semantic-layer type-resolution helpers.
+ *
+ * These helpers are purely semantic: they walk type expressions and EA paths
+ * using the compile environment and explicit layout casts, but they know
+ * nothing about placed/lowered program state or code-generation concerns.
+ *
+ * The lowering layer imports these helpers directly.
+ */
+export function createTypeResolutionHelpers(ctx) {
+    const resolveScalarKind = (typeExpr) => {
+        if (typeExpr.kind !== 'TypeName')
+            return undefined;
+        const lower = typeExpr.name.toLowerCase();
+        if (lower === 'byte' || lower === 'word' || lower === 'addr')
+            return lower;
+        return undefined;
+    };
+    const resolveAggregateType = (te) => {
+        if (te.kind === 'RecordType')
+            return { kind: 'record', fields: te.fields };
+        if (te.kind === 'TypeName') {
+            const decl = ctx.env.types.get(te.name);
+            if (!decl)
+                return undefined;
+            if (decl.kind === 'UnionDecl')
+                return { kind: 'union', fields: decl.fields };
+            if (decl.typeExpr.kind === 'RecordType') {
+                return { kind: 'record', fields: decl.typeExpr.fields };
+            }
+        }
+        return undefined;
+    };
+    const resolveArrayType = (te) => {
+        if (te.kind !== 'ArrayType')
+            return undefined;
+        return te.length === undefined
+            ? { element: te.element }
+            : { element: te.element, length: te.length };
+    };
+    const typeDisplay = (te) => {
+        const render = (x) => {
+            if (x.kind === 'TypeName')
+                return x.name;
+            if (x.kind === 'ArrayType') {
+                const inner = render(x.element);
+                return `${inner}[${x.length === undefined ? '' : x.length}]`;
+            }
+            if (x.kind === 'RecordType') {
+                return `record{${x.fields.map((f) => `${f.name}:${render(f.typeExpr)}`).join(',')}}`;
+            }
+            return 'type';
+        };
+        return render(te);
+    };
+    const sameTypeShape = (left, right) => {
+        if (left.kind !== right.kind)
+            return false;
+        switch (left.kind) {
+            case 'TypeName':
+                return right.kind === 'TypeName' && left.name.toLowerCase() === right.name.toLowerCase();
+            case 'ArrayType':
+                if (right.kind !== 'ArrayType')
+                    return false;
+                if (left.length !== right.length)
+                    return false;
+                return sameTypeShape(left.element, right.element);
+            case 'RecordType':
+                if (right.kind !== 'RecordType')
+                    return false;
+                if (left.fields.length !== right.fields.length)
+                    return false;
+                for (let i = 0; i < left.fields.length; i++) {
+                    const lf = left.fields[i];
+                    const rf = right.fields[i];
+                    if (lf.name !== rf.name || !sameTypeShape(lf.typeExpr, rf.typeExpr))
+                        return false;
+                }
+                return true;
+        }
+    };
+    const resolveEaTypeExprInternal = (ea) => {
+        switch (ea.kind) {
+            case 'EaName':
+                return undefined;
+            case 'EaAdd':
+            case 'EaSub':
+                return resolveEaTypeExprInternal(ea.base);
+            case 'EaLayoutCast': {
+                return ea.typeExpr;
+            }
+            case 'EaField': {
+                const baseType = resolveEaTypeExprInternal(ea.base);
+                if (!baseType)
+                    return undefined;
+                const agg = resolveAggregateType(baseType);
+                if (!agg)
+                    return undefined;
+                for (const f of agg.fields) {
+                    if (f.name === ea.field)
+                        return f.typeExpr;
+                }
+                return undefined;
+            }
+            case 'EaIndex': {
+                const baseType = resolveEaTypeExprInternal(ea.base);
+                if (!baseType)
+                    return undefined;
+                return resolveArrayType(baseType)?.element;
+            }
+            case 'EaImm':
+                return undefined;
+        }
+    };
+    const resolveEaTypeExpr = (ea) => resolveEaTypeExprInternal(ea);
+    return {
+        resolveScalarKind,
+        resolveAggregateType,
+        resolveArrayType,
+        resolveEaTypeExpr,
+        sameTypeShape,
+        typeDisplay,
+    };
+}

package/dist/src/sourceIncludeExpansion.d.ts

@@ -0,0 +1,17 @@
+import type { Diagnostic } from './diagnosticTypes.js';
+import type { DirectiveAliasPolicy } from './frontend/directiveAliases.js';
+export type ExpandedSource = {
+    text: string;
+    lineFiles: string[];
+    lineBaseLines: number[];
+};
+export declare function expandTextIncludesForFile(args: {
+    sourcePath: string;
+    sourceText: string;
+    includeDirs: string[];
+    diagnostics: Diagnostic[];
+    sourceTexts: Map<string, string>;
+    includeStack: string[];
+    aliasPolicy?: DirectiveAliasPolicy;
+    signal?: AbortSignal;
+}): Promise<ExpandedSource | undefined>;

package/dist/src/sourceIncludeExpansion.js

@@ -0,0 +1,124 @@
+import { readFile } from 'node:fs/promises';
+import { normalizePath } from './compileShared.js';
+import { DiagnosticIds } from './diagnosticTypes.js';
+import { resolveDirectiveAlias } from './frontend/directiveAliases.js';
+import { stripLineComment } from './frontend/parseParserShared.js';
+import { resolveIncludeCandidates } from './sourceIncludePaths.js';
+const INCLUDE_DIRECTIVE_RE = /^\s*([.]?[A-Za-z][A-Za-z0-9_]*)\b\s+"([^"]+)"\s*$/i;
+function throwIfAborted(signal) {
+    signal?.throwIfAborted();
+}
+function isIgnorableIncludeProbeError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const code = err.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}
+function includeDirectiveForLine(raw, aliasPolicy) {
+    const stripped = stripLineComment(raw).trim();
+    const match = INCLUDE_DIRECTIVE_RE.exec(stripped);
+    if (!match)
+        return undefined;
+    return resolveDirectiveAlias(match[1], aliasPolicy) === '.include' ? match[2] : undefined;
+}
+async function resolveIncludeSource(sourcePath, rawLine, spec, lineNo, includeDirs, diagnostics, sourceTexts, signal) {
+    const candidates = resolveIncludeCandidates(sourcePath, spec, includeDirs);
+    for (const c of candidates) {
+        throwIfAborted(signal);
+        try {
+            const resolvedText = await readFile(c, 'utf8');
+            const resolvedKey = normalizePath(c);
+            if (!sourceTexts.has(resolvedKey))
+                sourceTexts.set(resolvedKey, resolvedText);
+            return { resolved: c, resolvedText };
+        }
+        catch (err) {
+            if (isIgnorableIncludeProbeError(err))
+                continue;
+            diagnostics.push({
+                id: DiagnosticIds.IoReadFailed,
+                severity: 'error',
+                message: `Failed to read include candidate "${c}" while resolving includes for "${sourcePath}": ${String(err)}`,
+                file: sourcePath,
+                line: lineNo,
+                column: rawLine.indexOf('include') + 1 || 1,
+            });
+            return 'hard-failure';
+        }
+    }
+    diagnostics.push({
+        id: DiagnosticIds.IncludeNotFound,
+        severity: 'error',
+        message: `Failed to resolve include "${spec}" from "${sourcePath}". Tried:\n${candidates
+            .map((c) => `- ${c}`)
+            .join('\n')}`,
+        file: sourcePath,
+        line: lineNo,
+        column: rawLine.indexOf('include') + 1 || 1,
+    });
+    return undefined;
+}
+export async function expandTextIncludesForFile(args) {
+    const { sourcePath, sourceText, includeDirs, diagnostics, sourceTexts, includeStack, aliasPolicy, signal, } = args;
+    const sourceKey = normalizePath(sourcePath);
+    if (!sourceTexts.has(sourceKey))
+        sourceTexts.set(sourceKey, sourceText);
+    const lines = sourceText.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+    const out = [];
+    const lineFiles = [];
+    const lineBaseLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        throwIfAborted(signal);
+        const raw = lines[i] ?? '';
+        const lineNo = i + 1;
+        const spec = includeDirectiveForLine(raw, aliasPolicy);
+        if (!spec) {
+            out.push(raw);
+            lineFiles.push(sourcePath);
+            lineBaseLines.push(lineNo);
+            continue;
+        }
+        const resolvedInclude = await resolveIncludeSource(sourcePath, raw, spec, lineNo, includeDirs, diagnostics, sourceTexts, signal);
+        if (resolvedInclude === 'hard-failure')
+            return undefined;
+        if (!resolvedInclude) {
+            out.push(raw);
+            lineFiles.push(sourcePath);
+            lineBaseLines.push(lineNo);
+            continue;
+        }
+        if (includeStack.includes(resolvedInclude.resolved)) {
+            diagnostics.push({
+                id: DiagnosticIds.SemanticsError,
+                severity: 'error',
+                message: `Include cycle detected: "${resolvedInclude.resolved}" is already active in the include stack.`,
+                file: sourcePath,
+                line: lineNo,
+                column: raw.indexOf('include') + 1 || 1,
+            });
+            out.push(raw);
+            lineFiles.push(sourcePath);
+            lineBaseLines.push(lineNo);
+            continue;
+        }
+        const expanded = await expandTextIncludesForFile({
+            sourcePath: resolvedInclude.resolved,
+            sourceText: resolvedInclude.resolvedText,
+            includeDirs,
+            diagnostics,
+            sourceTexts,
+            includeStack: [...includeStack, resolvedInclude.resolved],
+            ...(aliasPolicy ? { aliasPolicy } : {}),
+            ...(signal ? { signal } : {}),
+        });
+        if (expanded === undefined)
+            return undefined;
+        const expandedLines = expanded.text.split('\n');
+        for (let j = 0; j < expandedLines.length; j++) {
+            out.push(expandedLines[j]);
+            lineFiles.push(expanded.lineFiles[j] ?? resolvedInclude.resolved);
+            lineBaseLines.push(expanded.lineBaseLines[j] ?? j + 1);
+        }
+    }
+    return { text: out.join('\n'), lineFiles, lineBaseLines };
+}

package/dist/src/sourceIncludePaths.d.ts

@@ -0,0 +1 @@
+export declare function resolveIncludeCandidates(fromSourcePath: string, specifier: string, includeDirs: string[]): string[];

package/dist/src/sourceIncludePaths.js

@@ -0,0 +1,12 @@
+import { dirname, resolve } from 'node:path';
+import { normalizePath } from './compileShared.js';
+export function resolveIncludeCandidates(fromSourcePath, specifier, includeDirs) {
+    const fromDir = dirname(fromSourcePath);
+    const out = [];
+    out.push(normalizePath(resolve(fromDir, specifier)));
+    for (const inc of includeDirs) {
+        out.push(normalizePath(resolve(inc, specifier)));
+    }
+    const seen = new Set();
+    return out.filter((p) => (seen.has(p) ? false : (seen.add(p), true)));
+}