@geastack/compiler 1.0.15

package/dist/cli-project.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { spawn } from 'node:child_process';
+import { discoverNodeProject } from './semantics/node-project.js';
+import { ensureDependencies } from './project-preparation.js';
+export const isNodeProjectArguments = (argv) => {
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === '--translation-units') {
+            const value = argv[index + 1];
+            if (value !== 'single' && value !== 'per-file' && value !== 'balanced')
+                return false;
+            index += 1;
+        }
+        else if (!['--dynamic-fallback', '--debug', '--emit-only', '--verbose'].includes(argument ?? '')) {
+            return false;
+        }
+    }
+    return true;
+};
+export const runNodeProject = async (argv) => {
+    if (!isNodeProjectArguments(argv))
+        throw new Error(`Unknown or invalid project option: ${argv.join(' ')}`);
+    let directory = process.cwd();
+    while (!existsSync(join(directory, 'package.json'))) {
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error('No package.json found. Run geatsc inside a Node project.');
+        directory = parent;
+    }
+    ensureDependencies(directory);
+    const project = discoverNodeProject(directory);
+    const packageRequire = createRequire(import.meta.url);
+    const driver = packageRequire.resolve('@geastack/node-compat/build');
+    for (const entry of project.entries) {
+        if (!/^[\w.-]+$/.test(entry.name) || entry.name === '.' || entry.name === '..')
+            throw new Error(`Invalid executable name: ${entry.name}`);
+        const dist = join(project.root, 'dist');
+        const out = join(dist, '.geatsc', entry.name);
+        mkdirSync(out, { recursive: true });
+        const executable = join(dist, process.platform === 'win32' ? `${entry.name}.exe` : entry.name);
+        console.error(`[geatsc] ${entry.file} -> ${executable}`);
+        const args = [driver, entry.file, '--out', out, '--exe', executable, '--report', join(out, 'report.json'), ...argv];
+        if (project.projectFile)
+            args.push('--source-project', project.projectFile);
+        const status = await new Promise((resolveStatus, reject) => {
+            const child = spawn(process.execPath, args, {
+                cwd: project.root,
+                stdio: 'inherit',
+                env: process.env
+            });
+            child.on('error', reject);
+            child.on('exit', (code) => resolveStatus(code ?? 1));
+        });
+        if (status !== 0)
+            return status;
+    }
+    return 0;
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare const main: (argv: readonly string[]) => Promise<number>;

package/dist/cli.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import { isNodeProjectArguments, runNodeProject } from './cli-project.js';
+import { compile } from './compiler.js';
+import { runEmit } from './cli-emit.js';
+import { runAnalyze } from './cli-analyze.js';
+import { runCoverage } from './cli-coverage.js';
+import { findProjectFile } from './semantics/program.js';
+import { preflightReportLines } from './preflight/report.js';
+import { structuralShapeKey } from './semantics/model/structural-types.js';
+import { closeSync, openSync, writeSync } from 'node:fs';
+/**
+ * `--project <tsconfig.json>` names the project explicitly; `--no-project`
+ * compiles the roots under this compiler's own defaults. With neither, the
+ * project nearest the first root file is used -- because a file's meaning is
+ * the meaning its own project gives it, and silently compiling it under
+ * different options reports defects the application does not have.
+ */
+const parseArguments = (argv) => {
+    const positional = argv.filter((argument) => !argument.startsWith('--'));
+    const flagIndex = argv.indexOf('--project');
+    const named = flagIndex >= 0 ? (argv[flagIndex + 1] ?? null) : null;
+    const rootFileNames = named ? positional.filter((argument) => argument !== named) : positional;
+    const first = rootFileNames[0];
+    const discovered = first ? findProjectFile(first.slice(0, Math.max(0, first.lastIndexOf('/'))) || '.') : null;
+    return {
+        rootFileNames,
+        preflight: argv.includes('--preflight'),
+        emit: argv.includes('--emit'),
+        projectFileName: argv.includes('--no-project') ? null : (named ?? discovered)
+    };
+};
+const formatDiagnostic = (diagnostic) => {
+    const where = diagnostic.location
+        ? `${diagnostic.location.file}:${diagnostic.location.line}:${diagnostic.location.column}`
+        : diagnostic.component;
+    const primitive = diagnostic.missingPrimitive ? ` [${diagnostic.missingPrimitive}]` : '';
+    // A bounded projection, not a truncation: a derived row in a large component
+    // cites every root in it, and printing all of them on every row buries the
+    // roots themselves. `--preflight` writes the complete census.
+    const causes = diagnostic.causedBy.length === 0
+        ? ''
+        : diagnostic.causedBy.length <= 3
+            ? `\n      caused by: ${diagnostic.causedBy.join(', ')}`
+            : `\n      caused by: ${diagnostic.causedBy.length} root row(s) in this component; see --preflight`;
+    return `  ${diagnostic.severity.padEnd(11)} ${where}${primitive}\n      ${diagnostic.message}${causes}`;
+};
+const usage = 'usage: geatsc [--dynamic-fallback] [--debug] [--emit-only] [--verbose] [--translation-units single|per-file|balanced] (build the current Node project)\n' +
+    'usage: geatsc <file.ts...> [--project <tsconfig.json>] [--no-project] [--preflight] [--emit] [--dynamic-fallback]\n' +
+    '       geatsc compile <input> --out-dir <dir> [--project <tsconfig.json>] [--target cpp] [--entry-symbol <symbol>] [--translation-units single|per-file|balanced] [--dynamic-fallback] [--closed-script-scope]\n' +
+    '       geatsc compile-module-graph <manifest> --entry <file> --out-dir <dir> [compile options, including --closed-script-scope]\n' +
+    '       --closed-script-scope asserts this compile is the complete classic-script lexical realm; it does not close globalThis or object mutation\n' +
+    '       compile options include [--plugin <module>]... [--plugin-option <key>=<value>]...\n' +
+    '       geatsc analyze <entry> --plugin <module>\n' +
+    '       geatsc coverage <entry> [--project <tsconfig.json>] [--no-project] [--plugin <module>] [--json] [--no-derived] [--no-boxed]';
+export const main = async (argv) => {
+    // `compile` is the build pipeline's own spelling (`build-gea-vite-geatsc.mjs`
+    // invokes `<bin> compile <input> --out-dir ...`), so it is dispatched before
+    // anything else parses argv: that command writes files and reports on stderr,
+    // where this one reports a census on stdout, and folding the two would make
+    // the diagnostic output part of a build's stdout contract.
+    if (argv[0] === 'compile')
+        return runEmit(argv.slice(1));
+    if (argv[0] === 'compile-module-graph')
+        return runEmit(argv.slice(1), true);
+    const parsed = parseArguments(argv);
+    if (parsed.rootFileNames.length === 0) {
+        process.stdout.write(`${usage}\n`);
+        return 1;
+    }
+    const result = compile({
+        rootFileNames: parsed.rootFileNames,
+        projectFileName: parsed.projectFileName,
+        dynamicFallback: argv.includes('--dynamic-fallback')
+    });
+    const lines = [];
+    lines.push(`semantics: ${result.graph.operations.size} operation(s), ${result.graph.structuralTypes.size} structural type(s), ` +
+        `${result.graph.edges.length} edge(s)`);
+    if (result.uninstalledFamilies.length > 0) {
+        lines.push(`uninstalled families: ${[...result.uninstalledFamilies].sort().join(', ')}`);
+    }
+    lines.push(`representations: ${result.representations.plan.selected.size} selected, ${result.representations.committed.length} component(s) ` +
+        `committed, ${result.representations.blocked.length} blocked, ${result.representations.violations.length} guard violation(s)`);
+    lines.push(`preflight: ${result.preflight.totals.mandatory.satisfied} satisfied, ${result.preflight.totals.mandatory.missing} missing, ` +
+        `${result.preflight.totals.mandatory.unsupported} unsupported, ${result.preflight.totals.mandatory.blockedByUpstream} blocked`);
+    // The certificate gates emission, not lowering: an uncertified program still
+    // lowers whatever its plan verified, and the IR certification's refusals
+    // print below like any other's (certification covers the lowered IR).
+    lines.push(result.certificate ? `certificate: ${result.certificate.id}` : 'certificate: not minted; nothing is emitted');
+    if (result.certificate) {
+        lines.push(result.source
+            ? `emitted: ${result.source.split('\n').length} line(s) of C++`
+            : `emitted: nothing; ${result.loweringBlockers.length} body/bodies have no IR lowering yet`);
+    }
+    // One list, every stage. A refused body is the answer, not an omission, so
+    // each row says which owner it is and what it lacked; a refused calling
+    // convention is a cause, not a consequence, and prints beside the bodies it
+    // stopped rather than being computed and shown to nobody.
+    //
+    // The `census` stage is SUMMARISED rather than enumerated, because it answers
+    // a different question from the rest of the list. An abi/lower/certify/print
+    // row says why a body produced no C++, and there are as many of those as
+    // there are refused bodies. A census row says why one CELL went untyped --
+    // the program still emits, just dynamically -- and a large program has
+    // thousands. Printing them beside the emission refusals would bury the
+    // answer this summary exists to give under the boxing report, so the counts
+    // per root go here and `CompileResult.refusals` keeps every row for the
+    // caller that wants them.
+    const censusRefusals = result.refusals.filter((refusal) => refusal.stage === 'census');
+    for (const refusal of result.refusals) {
+        if (refusal.stage === 'census')
+            continue;
+        lines.push(`  ${refusal.stage.padEnd(11)} ${refusal.owner}\n      ${refusal.reason}`);
+    }
+    if (censusRefusals.length > 0) {
+        const byRoot = new Map();
+        for (const refusal of censusRefusals)
+            byRoot.set(refusal.key, (byRoot.get(refusal.key) ?? 0) + 1);
+        lines.push(`census: ${censusRefusals.length} cell(s) untyped`);
+        for (const [key, count] of [...byRoot].sort((left, right) => right[1] - left[1]))
+            lines.push(`  ${String(count).padStart(6)} ${key}`);
+    }
+    if (result.diagnostics.diagnostics.length > 0) {
+        lines.push(`diagnostics (${result.diagnostics.diagnostics.length}):`);
+        for (const diagnostic of result.diagnostics.diagnostics)
+            lines.push(formatDiagnostic(diagnostic));
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+    // Written in bounded chunks, never as one string: see `preflightReportLines`.
+    if (parsed.preflight) {
+        let chunk = '';
+        for (const line of preflightReportLines(result.preflight)) {
+            chunk += line;
+            if (chunk.length >= 1 << 16) {
+                process.stdout.write(chunk);
+                chunk = '';
+            }
+        }
+        if (chunk.length > 0)
+            process.stdout.write(chunk);
+    }
+    // The structural type table beside the census, one `id<TAB>key` line per
+    // type, so a `type|N` a report row cites can be read back to the declared
+    // name (and, through `decl|fN|ordinal`, to its source) without re-running
+    // the frontend. An instrument like `GEA_STAGE_TIMING`, not a flag.
+    const dumpTypes = process.env['GEA_DUMP_STRUCTURAL_TYPES'];
+    if (dumpTypes) {
+        const out = openSync(dumpTypes, 'w');
+        let chunk = '';
+        for (const [id, type] of result.graph.structuralTypes) {
+            chunk += `${id}\t${structuralShapeKey(type.shape)}\n`;
+            if (chunk.length >= 1 << 16) {
+                writeSync(out, chunk);
+                chunk = '';
+            }
+        }
+        if (chunk.length > 0)
+            writeSync(out, chunk);
+        closeSync(out);
+    }
+    if (parsed.emit && result.source)
+        process.stdout.write(`${result.source}\n`);
+    return result.certificate ? 0 : 1;
+};
+const argv = process.argv.slice(2);
+// Compilation commands and host analysis load plugin modules asynchronously.
+if (argv.includes('--help') || argv.includes('-h')) {
+    process.stdout.write(`${usage}\n`);
+}
+else if (isNodeProjectArguments(argv)) {
+    void runNodeProject(argv)
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch((error) => {
+        console.error(`[geatsc] ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    });
+}
+else if (argv[0] === 'analyze') {
+    void runAnalyze(argv.slice(1)).then((code) => {
+        process.exitCode = code;
+    });
+}
+else if (argv[0] === 'coverage') {
+    // `coverage` may load a plugin module too, so it shares the asynchronous path.
+    void runCoverage(argv.slice(1)).then((code) => {
+        process.exitCode = code;
+    });
+}
+else {
+    void main(argv)
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch((error) => {
+        console.error(`[geatsc] ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    });
+}

package/dist/compiler.d.ts

@@ -0,0 +1,228 @@
+import type { PackageSource } from './semantics/package-sources.js';
+import { type AbiProjectionBlocker } from './projection/abi.js';
+import { type PhysicalClassLayoutPublication } from './projection/classes.js';
+import type { ConversionNode } from './conversion/algebra.js';
+import { type ConversionCensus } from './conversion/nodes.js';
+import type { ConversionRuntimeRegistry } from './conversion/registry.js';
+import type { DiagnosticLocation, DiagnosticReport } from './diagnostics/model.js';
+import type { DeclarationId, FunctionId, NodeId, OperationFamily, SemanticResultId } from './identity/ids.js';
+import type { CallableAbi } from './representation/model.js';
+import type { ClassLayout } from './projection/classes.js';
+import type { BindingPlacement } from './projection/bindings.js';
+import type { SlotHook } from './projection/slots.js';
+import type { CapabilityCertificate } from './ir/certificate.js';
+import { type Refusal } from './ir/refusal.js';
+import type { TargetRuntimeManifest } from './preflight/obligations.js';
+import type { PreflightReport } from './preflight/run.js';
+import type { RepresentationPublication } from './representation/publish.js';
+import { type CensusAccounting } from './semantics/frontend.js';
+import type { CellFactsPublication } from './semantics/normalize/cells/index.js';
+import type { DiagnosticSourcePreparationAudit } from './semantics/diagnostic-source-preparation.js';
+import type { SemanticGraph } from './semantics/model/graph.js';
+import type { CompilerPlugin, PluginInstance, PluginOptions } from './plugins/model.js';
+import type { IrLoweringBlocker } from './ir/lower.js';
+import type { SlotDrift } from './ir/lower-operands.js';
+import { type IrCertification } from './ir/certify.js';
+import type { IrBody } from './ir/model.js';
+import { type EmissionRepresentationPublication } from './ir/emission-representations.js';
+import { type ReflectionExposure } from './ir/reflection-demand.js';
+import type { PrinterDrift } from './targets/cpp/emit-narrowing.js';
+import type { RenderedCppSource } from './targets/cpp/document.js';
+import { type CppEmissionRefusal, type CppRenderedUnit, type CppTranslationUnitLayout } from './targets/cpp/translation-unit.js';
+/**
+ * The compilation pipeline.
+ *
+ * The stage order here is the architecture's mandatory publication order, and
+ * every stage consumes only what the previous one sealed:
+ *
+ *   normalize -> publish carriers -> derive conversions -> preflight -> certify
+ *   -> project ABIs -> lower to IR -> render
+ *
+ * Lowering is gated on the plan, emission on the certificate. A program whose
+ * frontend, census and plan raised nothing (`DiagnosticReport.planClean`)
+ * lowers whether or not preflight certified it, and every body lowering
+ * cannot build is a `Refusal` row beside preflight's own; this is what lets
+ * certification move onto the IR --
+ * a check over operations that exist rather than a model of operations that
+ * would. Text is still produced only under a certificate with every body
+ * lowered: a stage that renders before the certificate exists can discover,
+ * halfway through emission, that a capability it needed was never installed,
+ * which is the failure mode preflight exists to remove.
+ */
+export interface CompilationRequest {
+    /** Package checkouts prepared by the project loader; the compiler discovers their implementation entries. */
+    readonly packageSources?: readonly PackageSource[];
+    /** Opt in to boxed C++ carriers where static specialization cannot select storage. */
+    readonly dynamicFallback?: boolean;
+    readonly rootFileNames: readonly string[];
+    /** The project file defining this program. `null` compiles the roots under this compiler's own defaults. */
+    readonly projectFileName?: string | null;
+    /** The target's installed conversion primitives; empty means none are built yet. */
+    readonly conversionRegistry?: ConversionRuntimeRegistry;
+    /** Libraries whose meaning this program depends on. Defaults to what this build installs. */
+    readonly plugins?: readonly CompilerPlugin[];
+    /** What the build told those libraries -- see `PluginOptions`. Empty when the caller passed none. */
+    readonly pluginOptions?: PluginOptions;
+    /**
+     * The C++ name the target starts this program at, or `null` to emit no entry.
+     *
+     * The gea runtimes call `__gea_top_level`, which is why that is the default:
+     * `core/gea_app_entry.cpp` declares it and `Application::init` invokes it, so
+     * an emitted unit links against the engine as it stands. A resident-app build
+     * gives each app its own prefixed entry so several link together, and a
+     * caller inspecting a unit rather than linking it can ask for none.
+     */
+    readonly entrySymbol?: string | null;
+    /**
+     * Legacy explicit JavaScript admission. JavaScript dependencies are now admitted automatically.
+     *
+     * The gea build pipeline hands its compiler a vite bundle, not the app's
+     * TypeScript: plain JS with JSDoc annotations and a generated `.d.ts`
+     * reference. Saying so is a statement about the input; what the checker is
+     * then configured with is `semantics/`'s to decide (`FrontendInput`).
+     */
+    readonly javaScriptSources?: boolean;
+    /** File text this compilation uses instead of what is on disk, by absolute path. */
+    readonly sourceOverlay?: ReadonlyMap<string, string>;
+    /** How each file's own import specifiers resolve, when the build is the authority. */
+    readonly moduleResolution?: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    /** Whether this request states the module set -- see `ProgramInput.statedModuleSet`. */
+    readonly statedModuleSet?: boolean;
+    /** Caller-stated classic-script lexical realm boundary; see `ProgramInput.closedScriptScope`. */
+    readonly closedScriptScope?: boolean;
+    /** Whether the emitted unit is one of several a single binary links -- see `TranslationUnitInput.isolateSymbols`. */
+    readonly isolateSymbols?: boolean;
+    /** Retain final IR in the result for diagnostics. Off by default so normal builds can release it. */
+    readonly includeIr?: boolean;
+    /**
+     * How many C++ files the program becomes -- see `CppTranslationUnitLayout`.
+     * `single` (the default) is one unit; `per-file` is one unit per source file
+     * plus a shared header and a program unit.
+     */
+    readonly translationUnits?: CppTranslationUnitLayout;
+    /**
+     * The stem the emitted files are named from (`<stem>.cpp`, and under
+     * `per-file` also `<stem>.hpp` and `<stem>.<module>.cpp`). The CLI passes the
+     * input's own base name; the default is `unit`.
+     */
+    readonly unitBaseName?: string;
+}
+export interface CompilationResult {
+    readonly dynamicFallback: {
+        readonly enabled: boolean;
+        readonly valueCount: number;
+    };
+    /**
+     * Where a node identity is, for display -- the frontend's own identity walk
+     * (`FrontendResult.locationOfNode`). Exposed so a reader of the plan can put
+     * a carrier at a place in the program: the diagnostic sweep already does this
+     * for every failing row, and `cli-coverage.ts` asks the same question of the
+     * rows that did NOT fail -- which carriers boxed, and where.
+     */
+    readonly locationOfNode: (node: NodeId) => DiagnosticLocation | null;
+    /** `locationOfNode`'s twin for a DeclarationId (`FrontendResult.locationOfDeclaration`) -- see `AbiProjectionBlocker.location`. */
+    readonly locationOfDeclaration: (declaration: DeclarationId) => DiagnosticLocation | null;
+    /** The node's source text, for display (`FrontendResult.textOfNode`). */
+    readonly textOfNode: (node: NodeId) => string | null;
+    readonly graph: SemanticGraph;
+    /** Stable file identities used in declaration and function ids, mapped to display paths. */
+    readonly sourceFileNames: ReadonlyMap<string, string>;
+    /** Diagnostic-proven stale package-source directives removed before the final checker pass. */
+    readonly sourcePreparations: readonly DiagnosticSourcePreparationAudit[];
+    readonly representations: RepresentationPublication;
+    readonly manifest: TargetRuntimeManifest;
+    readonly preflight: PreflightReport;
+    /** Non-null only when every mandatory obligation was satisfied. */
+    readonly certificate: CapabilityCertificate | null;
+    readonly diagnostics: DiagnosticReport;
+    readonly uninstalledFamilies: readonly OperationFamily[];
+    /** What each write-discovery census bound and why it refused the rest -- see `FrontendOutput.censusAccounting`. */
+    readonly censusAccounting: ReadonlyMap<string, CensusAccounting>;
+    /**
+     * The frontend's per-cell fact table, forwarded verbatim (`FrontendResult.cellFacts`).
+     * Exposed so a caller can ask `cellFacts.table.twoOwnerClaims` -- the cells two
+     * independent write-discovery censuses both claimed -- without threading a new
+     * field through every stage that already forwards `frontend.graph` the same way.
+     */
+    readonly cellFacts: CellFactsPublication;
+    /**
+     * The derived conversion graph, keyed by carrier.
+     *
+     * Exposed because a `conversion-capability` obligation carries only its
+     * predicate STRING -- `return-conversion:<source key>-><target key>` -- and
+     * a bare "absent" says nothing about why. The node's own `capability` holds
+     * the `never` REASON the derivation stated, which is the actual root: 35
+     * distinct carrier pairs on the three.js app collapsed to a handful of reasons the
+     * first time this was asked, and the pair keys had been ranked as 35
+     * separate problems until then.
+     */
+    readonly conversionNodes: ReadonlyMap<string, ConversionNode>;
+    /**
+     * The conversion census over the same registry: one node per carrier
+     * pair, the eager graph's where it minted one and otherwise minted on
+     * demand from the registry's tables (`conversion/nodes.ts`). This is the
+     * authority the lowering's `convert` instructions name.
+     */
+    readonly conversionCensus: ConversionCensus;
+    /** Physical carrier dependencies and reflection demands of the final emitted program. */
+    readonly emissionRepresentations: EmissionRepresentationPublication | null;
+    readonly reflection: ReflectionExposure | null;
+    /** Final IR supplied to certification, including published callable identities. Null unless requested by includeIr. */
+    readonly irBodies: readonly IrBody[] | null;
+    readonly physicalClasses: PhysicalClassLayoutPublication | null;
+    /**
+     * The program as one unit. Non-null only when a certificate was minted,
+     * every body lowered, and the layout is `single`; under `per-file` the
+     * program is `units`, and there is no one text that is all of it.
+     */
+    readonly source: RenderedCppSource | null;
+    /** Every C++ file the layout produced, named and in write order; empty whenever `source` would be null for a `single` layout. */
+    readonly units: readonly CppRenderedUnit[];
+    /** Bodies the IR refused, each naming what has no primitive yet. */
+    readonly loweringBlockers: readonly IrLoweringBlocker[];
+    /** Every refusal past the plan -- ABI, lowering and printer -- as one list (`ir/refusal.ts`). */
+    /** The IR certification's verdict, or `null` for a program that did not lower; `certificate` is minted from it. */
+    readonly certification: IrCertification | null;
+    readonly refusals: readonly Refusal[];
+    /** Slots lowering left unconverted because the conversion census has no node for the pair (`ir/lower-operands.ts`'s `SlotDrift`). */
+    readonly slotDrift: readonly SlotDrift[];
+    /** Every chain call the printer still made on a pair lowering had not aligned; `emit-narrowing.ts`'s `PrinterDrift`. */
+    readonly printerDrift: readonly PrinterDrift[];
+    /** Functions whose calling convention could not be projected, each naming why. */
+    readonly abiBlockers: readonly AbiProjectionBlocker[];
+    /** Bodies the C++ emitter refused, each naming the capability it lacked. */
+    readonly emissionRefusals: readonly CppEmissionRefusal[];
+    /** The whole-program projections lowering consumes, published so the slot census can be asked outside the pipeline. */
+    readonly projection: {
+        readonly abis: ReadonlyMap<FunctionId, CallableAbi>;
+        readonly constructs: ReadonlyMap<FunctionId, CallableAbi>;
+        readonly callableOrigins: ReadonlyMap<SemanticResultId, FunctionId>;
+        readonly classes: ReadonlyMap<DeclarationId, ClassLayout>;
+        readonly placements: ReadonlyMap<DeclarationId, BindingPlacement>;
+        readonly slotHooks: readonly SlotHook[];
+    };
+    /**
+     * The installed plugins' own `writeArtifacts`, for the caller to run against
+     * its output directory once it has written a unit.
+     *
+     * Returned rather than called here because this function does not know where
+     * -- or whether -- anything is written. `compile` produces a result; the CLI
+     * decides that the result is worth putting on disk and where it goes, and an
+     * artifact a plugin's host requires beside the unit is part of that same
+     * decision. Empty for every compilation whose plugins state one.
+     */
+    readonly artifacts: readonly ((outDir: string) => void)[];
+    /**
+     * Header paths the caller's `generated_support.hpp` must state, unioned from
+     * the installed plugins -- see `PluginCapabilities.generatedSupportIncludes`.
+     * Returned for the same reason `artifacts` is: this function does not write
+     * files, and what a unit is compiled against is a fact of the compilation
+     * rather than of the directory it lands in.
+     */
+    readonly generatedSupportIncludes: readonly string[];
+}
+export declare const sourceTransformsFor: (plugins: readonly PluginInstance[]) => readonly ((input: {
+    readonly fileName: string;
+    readonly text: string;
+}) => string | null)[];
+export declare const compile: (request: CompilationRequest) => CompilationResult;