@scriptc/compiler 0.4.0 → 0.4.2

package/dist/index.js

@@ -10,21 +10,28 @@ import { commentOnlyReplay } from "./coverage/verdict-semantic.js";
 import { llvmRefusalDiag, targetRefusalDiag } from "./backend/target-diagnostics.js";
 import { compilePackedLibrary } from "./backend/library-pack.js";
 import { InternalCompilerError } from "./errors.js";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { frontendProcessExecArgv } from "./frontend-process-args.js";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { clearCcCaches, configuredTargetPlatform, } from "./backend/native-toolchain.js";
 import { buildCacheRoot, prepareBuildCacheRoot, pruneBuildCache } from "./backend/build-cache.js";
 import { CcCompileError, compileExternalC, compileExternalCLibrary, executableNativeEnvironmentFingerprint, mobileLibraryTarget, mobileTargetRefusal, resolveCc, } from "./backend/external-c.js";
-import { emitLlvmModuleSource, LlvmUnsupportedError } from "./backend/llvm/emitter.js";
+import { emitLlvmModuleSource, LlvmUnsupportedError, lowRegionTarget, } from "./backend/llvm/emitter.js";
 import { inlineRcOption } from "./backend/llvm/shapes.js";
-import { emitNativeArtifact, NativeCodegenError, writeLlvmSource, } from "./backend/native-codegen.js";
+import { emitNativeArtifact, isLlvmFile, llvmInputBytes, NativeCodegenError, writeLlvmSource, } from "./backend/native-codegen.js";
 import { nativePartitionPaths, nativeProgramPartitions } from "./backend/native-codegen-core.js";
 import { privateSiblingPath } from "./backend/build-cache.js";
 import { nativeCodegenTarget, nativeCodegenTargetRefusal } from "./backend/targets.js";
 import { windowsSubsystemLinkerArgs } from "./backend/targets.js";
 import { createNativeLinkInfo } from "./backend/native-link-info.js";
-import { RuntimePackError, loadRuntimeBitcode } from "./backend/runtime-pack.js";
+import { RuntimePackError } from "./backend/runtime-pack.js";
 import { createNativeLinkPlan } from "./backend/link-plan.js";
+import { nativeProfileKey, nativeProfileRefusal, } from "./backend/native-profile.js";
 import { executableLinkerEnvironmentFingerprint, linkNativeExecutable, platformLinkerSupportsPersistentCache, resolvePlatformLinker, } from "./backend/linker.js";
 import { splitLlvmLibraryProgram, splitLlvmProgram } from "./backend/llvm/split.js";
 import { emitLibraryIdentityLines, replaceLibraryIdentity, stripLibraryIdentity, } from "./backend/library-identity-markers.js";
@@ -35,24 +42,27 @@ import { canonicalModuleGraph, clearSidecarCaches, compilerReleaseVersion, libra
 import {} from "./ir/ir.js";
 import { moduleRuntimeFeatures } from "./ir/runtime-features.js";
 import { serializeModuleParts } from "./ir/serialize.js";
-import { writeTextParts } from "./text-parts.js";
+import { readTextParts, writeTextParts } from "./text-parts.js";
 import { validateModule } from "./ir/validate.js";
 import { loadProgram } from "./frontend/program-node.js";
 import { runFrontend } from "./frontend/pipeline.js";
-import { provenanceSources } from "./frontend/provenance-registry.js";
+import { provenanceSources, setProvenanceSources, } from "./frontend/provenance-registry.js";
 import { clearResolveCaches } from "./frontend/resolve.js";
 import { loadFfiProfile } from "./ffi/ffi-manifest.js";
 import { executableLinkFeatures } from "./backend/executable-features.js";
 import { youngNurseryRequested } from "./backend/young-nursery.js";
-import { FrontendInputTracker, trackedReadFile } from "./frontend/input-tracker.js";
+import { FrontendInputTracker, trackedReadFile, } from "./frontend/input-tracker.js";
 import { libraryFrontendImplementationFingerprint, publishEarlyLibraryCache, readEarlyLibraryCache, readSemanticLibraryCache, } from "./library/library-cache.js";
-import { publishEarlyExecutableCache, publishEarlyExecutableRoute, readEarlyExecutableCache, } from "./executable/executable-cache.js";
+import { hasEarlyExecutableNativeBuild, publishEarlyExecutableCache, publishEarlyExecutableRoute, readEarlyExecutableCache, recordEarlyExecutableNativeBuild, } from "./executable/executable-cache.js";
 import { compilerImplementationIdentity } from "./library/compiler-self-identity.js";
+import { isPerformanceCode } from "./diagnostics/dynamic-tier.js";
 export const VERSION = "0.0.1";
 export { EXTERNAL_OBJECT_ABI_STABILITY, RUNTIME_ABI_MARKER, RUNTIME_ABI_VERSION, } from "./backend/runtime-abi.js";
 export { InternalCompilerError } from "./errors.js";
 export { compileExternalC as compileC, compileExternalC, runtimeSrcDir, } from "./backend/external-c.js";
 export { warmNativeCaches } from "./backend/warm-cache.js";
+export { mergeNativeProfiles as mergeProfiles } from "./backend/native-codegen.js";
+export { collectGarbageUnderHeapPressure } from "./heap-collection.js";
 export { ANDROID_MIN_API, IPHONEOS_MIN_VERSION, isAndroidTarget, isIosTarget, isMobileTarget, mobileLibraryTarget, mobileTargetRefusal, } from "./backend/external-c.js";
 export { emitLlvmModule } from "./backend/llvm/emitter.js";
 export { renderDiagnostics, renderDiagnostics as renderAll, renderDiagnostic, } from "./diagnostics/render.js";
@@ -143,8 +153,21 @@ export async function compile(entryPath, opts) {
     clearCompileSessionCaches();
     const frontendInputs = new FrontendInputTracker();
     const warnings = { warnings: [], sourceTexts: null };
-    const result = await frontendInputs.run(() => compileTracked(entryPath, opts, frontendInputs, warnings));
-    return withCompileWarnings(result, warnings);
+    // compileTracked starts it for a build with no earlier build of the same invocation.
+    const frontendProcess = preparesInChildProcess(opts) ? new FrontendProcess() : undefined;
+    try {
+        const result = await frontendInputs.run(() => compileTracked(entryPath, opts, frontendInputs, warnings, frontendProcess));
+        return withCompileWarnings(result, warnings);
+    }
+    finally {
+        frontendProcess?.release();
+    }
+}
+/** The build's performance warnings (SC61xx), stored with its cache entry
+ * so a cache hit repeats them. */
+function performanceWarnings(sink) {
+    const performance = (sink?.warnings ?? []).filter((d) => isPerformanceCode(d.code));
+    return performance.length === 0 ? {} : { performance };
 }
 function withCompileWarnings(result, sink) {
     if (!result.ok || sink.warnings.length === 0)
@@ -176,7 +199,10 @@ function executableNativeFeatures(mod, backend, optimization) {
         ...executableLinkFeatures(mod),
     };
 }
-async function compileExecutableNative(features, llvmPath, outPath, sanitize, ffi, windowsSubsystem, strip, programSplit = null, programObjectDependencies = [], onArtifactReady, programPartitions = []) {
+async function compileExecutableNative(features, llvmPath, outPath, sanitize, ffi, windowsSubsystem, strip, programSplit = null, programObjectDependencies = [], onArtifactReady, programPartitions = [], profileGenerate = false, 
+/** The kept LLVM text's shared name, when `llvmPath` is the build's private copy of it
+ * (BuildSources): the spelling clang sees and native cache keys name. */
+llvmVisiblePath) {
     const programIsObject = /\.(?:o|obj)$/.test(llvmPath);
     const runtimePackTarget = programIsObject && !sanitize ? nativeCodegenTarget() : null;
     if (runtimePackTarget !== null) {
@@ -190,6 +216,7 @@ async function compileExecutableNative(features, llvmPath, outPath, sanitize, ff
             optimization: features.optimization ?? "release",
             ...(strip ? { strip: true } : {}),
             ...(windowsSubsystem === undefined ? {} : { windowsSubsystem }),
+            ...(profileGenerate ? { profileGenerate: true } : {}),
             programObjectDependencies,
         });
         const cacheableLinker = onArtifactReady !== undefined &&
@@ -212,7 +239,9 @@ async function compileExecutableNative(features, llvmPath, outPath, sanitize, ff
     if (programIsObject)
         throw new InternalCompilerError("program objects must link against a precompiled runtime pack");
     await compileExternalC({
-        cPath: llvmPath,
+        ...(llvmVisiblePath === undefined || llvmVisiblePath === llvmPath
+            ? { cPath: llvmPath }
+            : { cPath: llvmVisiblePath, cSourcePath: llvmPath }),
         outPath,
         cacheIdentity: "scriptc-generated-v1",
         ...optimizationField(features.optimization),
@@ -242,13 +271,18 @@ async function compileExecutableNative(features, llvmPath, outPath, sanitize, ff
         dynAsync: features.dynAsync,
         ...(features.dynTier ? { dynTier: true } : {}),
         ...(features.streamDyn ? { streamDyn: true } : {}),
+        ...(features.handleProps ? { handleProps: true } : {}),
+        ...(features.dynForAwait ? { dynForAwait: true } : {}),
         ...(features.eventsOnceSignal ? { eventsOnceSignal: true } : {}),
+        ...(features.dynBuffer ? { dynBuffer: true } : {}),
+        ...(features.builtinValues ? { builtinValues: true } : {}),
         events: features.events,
         emitter: features.emitter,
         symbol: features.symbol,
         bigint: features.bigint,
         searchParams: features.searchParams,
         qs: features.qs,
+        utilPromisify: features.utilPromisify,
         dynBuiltinClass: features.dynBuiltinClass,
         dynBuiltinStream: features.dynBuiltinStream,
         parseArgs: features.parseArgs,
@@ -258,6 +292,7 @@ async function compileExecutableNative(features, llvmPath, outPath, sanitize, ff
         http2: features.http2,
         dgram: features.dgram,
         dnsPromises: features.dnsPromises,
+        dgramDyn: features.dgramDyn,
         watch: features.watch,
         foreignFfi: features.foreignFfi,
         ...(features.workers ? { workers: true } : {}),
@@ -266,6 +301,10 @@ async function compileExecutableNative(features, llvmPath, outPath, sanitize, ff
         tls: features.tls,
         tlsCa: features.tlsCa,
         cipher: features.cipher,
+        ecdh: features.ecdh,
+        dh: features.dh,
+        pki: features.pki,
+        ed25519: features.ed25519,
         webcrypto: features.webcrypto,
         perfLoop: features.perfLoop,
         ...(onArtifactReady === undefined ? {} : { onArtifactReady }),
@@ -278,7 +317,7 @@ async function compileExecutableNative(features, llvmPath, outPath, sanitize, ff
             }),
     });
 }
-async function emitNativeProgramObject(entryPath, opts, llvm, features) {
+async function emitNativeProgramObject(entryPath, opts, llvm, profile) {
     const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
     const artifactPath = join(opts.outDir, `${stem}.helper.o`);
     // compileExecutableNative recognizes object inputs by suffix. The random
@@ -287,25 +326,8 @@ async function emitNativeProgramObject(entryPath, opts, llvm, features) {
     const linkPath = `${privateSiblingPath(artifactPath, "native-program-object")}.o`;
     // The validated program-object artifact is a single object by contract.
     const target = nativeCodegenTarget();
-    const llvmBytes = (typeof llvm === "string" ? [llvm] : llvm).reduce((bytes, part) => bytes + Buffer.byteLength(part), 0);
+    const llvmBytes = llvmInputBytes(llvm);
     const partitions = opts.nativeProgramObject === true || target === null ? 1 : nativeProgramPartitions(llvmBytes);
-    // Optimized programs import small runtime functions from the bitcode of
-    // the exact runtime units they link, so LLVM can inline across the
-    // boundary. Release units ship only the bodies that need none of their
-    // unit-local state, which keeps the import cheap; speed units promote
-    // that state and offer more. Every partition reads the bitcode again, so
-    // release imports only into programs small enough for one partition: in
-    // larger ones the build-time and size cost outgrows the gain.
-    const runtimeBitcode = opts.sanitize !== true &&
-        target !== null &&
-        (opts.optimization === "speed" ||
-            (opts.optimization !== "dev" && nativeProgramPartitions(llvmBytes) === 1))
-        ? await loadRuntimeBitcode({
-            target,
-            features,
-            optimization: opts.optimization === "speed" ? "speed" : "release",
-        })
-        : null;
     try {
         const artifact = await emitNativeArtifact({
             outputPath: linkPath,
@@ -315,15 +337,13 @@ async function emitNativeProgramObject(entryPath, opts, llvm, features) {
             optimization: opts.optimization === "dev" ? "0" : "2",
             ...(opts.sanitize === undefined ? {} : { sanitize: opts.sanitize }),
             partitions,
-            ...(runtimeBitcode === null
-                ? {}
-                : { importBitcode: { paths: runtimeBitcode.paths, digests: runtimeBitcode.digests } }),
+            ...(profile === undefined ? {} : { profile }),
         });
         return {
             linkPath,
             partitionPaths: artifact.outputPaths.slice(1),
             artifactPath,
-            dependencies: [...artifact.dependencies, ...(runtimeBitcode?.dependencies ?? [])],
+            dependencies: artifact.dependencies,
         };
     }
     catch (error) {
@@ -334,6 +354,23 @@ async function emitNativeProgramObject(entryPath, opts, llvm, features) {
 async function removeNativeProgramObject(linkPath, partitionPaths) {
     await Promise.all([linkPath, ...partitionPaths].map((path) => rm(path, { force: true }).catch(() => undefined)));
 }
+/** The request's profile. An indexed profile is read here so every cache keys
+ * its bytes. */
+async function readNativeProfile(opts) {
+    if (opts.profileGenerate !== undefined)
+        return { generate: opts.profileGenerate };
+    if (opts.profileUse === undefined)
+        return undefined;
+    const path = resolve(opts.profileUse);
+    let bytes;
+    try {
+        bytes = await readFile(path);
+    }
+    catch (err) {
+        throw new Error(`cannot read --profile-use file ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return { use: { path, digest: createHash("sha256").update(bytes).digest("hex") } };
+}
 function usesPrecompiledRuntimePack(opts, backend) {
     if (backend !== "llvm" || opts.sanitize === true)
         return false;
@@ -375,6 +412,7 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
                 wasi: buildPlatform === "wasi",
                 runtimeAbiMarker: outputKind === "obj",
                 objectAudit: opts.sanitize === true,
+                lowRegion: lowRegionTarget(buildPlatform, opts.sanitize === true),
                 ...(opts.sanitize === true ? { wasmBoundsChecks: true } : {}),
                 ...inlineRcOption(opts.optimization, opts.sanitize === true),
             });
@@ -433,6 +471,8 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
     }
     await mkdir(opts.outDir, { recursive: true });
     const llvmPath = defaultSourcePaths.llvm;
+    // The extension keeps clang reading the copy as LLVM IR rather than as a linker input.
+    const llvmSourcePath = `${privateSiblingPath(llvmPath, "llvm")}.ll`;
     const backend = "llvm";
     const useRuntimePack = opts.nativeProgramObject === true || usesPrecompiledRuntimePack(opts, backend);
     let llvmSource;
@@ -444,6 +484,7 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
             wasi: buildPlatform === "wasi",
             runtimeAbiMarker: useRuntimePack,
             objectAudit: opts.sanitize === true,
+            lowRegion: lowRegionTarget(buildPlatform, opts.sanitize === true),
             ...(opts.sanitize === true ? { wasmBoundsChecks: true } : {}),
             ...inlineRcOption(opts.optimization, opts.sanitize === true),
             ...(opts.detachedExit === true ? { detachedExit: true } : {}),
@@ -455,12 +496,14 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         return { ok: false, diagnostics: [llvmRefusalDiag(err, entryPath)], sourceTexts };
     }
     timing("llvm-emit");
-    await writeLlvmSource(llvmPath, llvmSource);
+    await writeLlvmSource(llvmSourcePath, llvmSource);
     timing("llvm-write");
     let irPath;
+    let irSourcePath;
     if (opts.emitIr) {
         irPath = defaultSourcePaths.ir;
-        await writeTextParts(irPath, serializeModuleParts(mod));
+        irSourcePath = privateSiblingPath(irPath, "ir");
+        await writeTextParts(irSourcePath, serializeModuleParts(mod));
     }
     const nativeFeatures = executableNativeFeatures(mod, backend, opts.optimization ?? "release");
     timing("link-features");
@@ -472,10 +515,243 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         ? splitLlvmProgram(llvmSource)
         : null;
     timing("llvm-split");
-    return { llvmSource, llvmPath, irPath, nativeFeatures, programSplit, sourceTexts };
+    return {
+        llvmSource,
+        llvmPath,
+        llvmSourcePath,
+        irPath,
+        irSourcePath,
+        nativeFeatures,
+        programSplit,
+        sourceTexts,
+    };
+}
+/** Moves a build's private copies to the shared names, or drops them when that fails. */
+async function installBuildSources(sources) {
+    const install = async (source, destination, current) => {
+        if (source === undefined || destination === undefined || source === destination)
+            return;
+        if (current === true)
+            await rm(source, { force: true });
+        else
+            await rename(source, destination).catch(() => rm(source, { force: true }));
+    };
+    await Promise.all([
+        install(sources.llvmSourcePath, sources.llvmPath, sources.llvmPathCurrent),
+        install(sources.irSourcePath, sources.irPath, sources.irPathCurrent),
+    ]);
+}
+/**
+ * A build that compiles the LLVM text with the C driver (no precompiled runtime pack) records the
+ * output directory in its native cache proofs, so that directory has to be in its final state before
+ * the native build starts. The build therefore installs the shared names first and compiles and
+ * caches copies in a private directory outside the output directory. Returns that directory and the
+ * copies.
+ */
+async function stageDriverBuildSources(sources) {
+    const dir = await mkdtemp(join(tmpdir(), "scriptc-program-"));
+    const llvmSourcePath = join(dir, basename(sources.llvmPath));
+    const irSourcePath = sources.irPath === undefined || sources.irSourcePath === undefined
+        ? undefined
+        : join(dir, basename(sources.irPath));
+    try {
+        await Promise.all([
+            copyFile(sources.llvmSourcePath, llvmSourcePath),
+            irSourcePath === undefined || sources.irSourcePath === undefined
+                ? undefined
+                : copyFile(sources.irSourcePath, irSourcePath),
+        ]);
+    }
+    catch (err) {
+        await rm(dir, { recursive: true, force: true });
+        throw err;
+    }
+    await installBuildSources(sources);
+    return {
+        dir,
+        sources: { llvmPath: sources.llvmPath, llvmSourcePath, irPath: sources.irPath, irSourcePath },
+    };
+}
+/**
+ * The child process that prepares an executable build's input: frontend, lowering and LLVM emission
+ * (`runFrontendProcess`). Node's heap keeps the pages a build's frontend used for the life of the
+ * process, so running them in a process of their own leaves the native helper the memory they took.
+ */
+const frontendProcessEntry = fileURLToPath(new URL("./frontend-process.js", import.meta.url));
+/**
+ * Whether `prepareExecutableInputInChild` may prepare this build: optimized executables, when the
+ * compiler runs from its built files. Development builds split the LLVM text in this process, and
+ * SCRIPTC_FRONTEND_PROCESS=0 keeps the frontend in-process.
+ *
+ * compileTracked starts the process only when no earlier build of the same invocation emitted its
+ * native program object (`hasEarlyExecutableNativeBuild`). A rebuild finds most native partitions
+ * in the helper's cache, so its memory peaks in the frontend, and the parent process would add to
+ * that peak.
+ */
+function preparesInChildProcess(opts) {
+    return (process.env["SCRIPTC_FRONTEND_PROCESS"] !== "0" &&
+        (opts.outputKind ?? "exe") === "exe" &&
+        (opts.optimization ?? "release") !== "dev" &&
+        existsSync(frontendProcessEntry));
 }
-async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
+/**
+ * The frontend process (frontend-process.ts) of one compile. `start` launches it; it then waits on
+ * its stdin for the paths of a request and its result (`run`), and exits once its stdin closes
+ * without them (`release`).
+ */
+class FrontendProcess {
+    child;
+    exited;
+    sent = false;
+    /** Whether `start` launched the process. */
+    get started() {
+        return this.child !== undefined;
+    }
+    start() {
+        if (this.child !== undefined)
+            return;
+        const execArgv = frontendProcessExecArgv(process.execArgv);
+        const child = spawn(process.execPath, [...execArgv, frontendProcessEntry], {
+            stdio: ["pipe", "inherit", "inherit"],
+        });
+        this.exited = new Promise((resolveExit) => {
+            child.on("error", () => resolveExit(null));
+            child.on("exit", (code) => resolveExit(code));
+        });
+        // A failed start surfaces as a failed run; the build then prepares its input in-process.
+        child.stdin.on("error", () => undefined);
+        this.child = child;
+    }
+    /** Sends the request at `requestPath`; resolves with the process's exit code. */
+    run(requestPath, resultPath) {
+        if (this.child === undefined || this.exited === undefined || this.sent)
+            return Promise.resolve(null);
+        this.sent = true;
+        this.child.stdin.end(`${requestPath}\n${resultPath}\n`);
+        return this.exited;
+    }
+    /** Lets the process exit if no request was sent. */
+    release() {
+        if (this.child === undefined || this.sent)
+            return;
+        this.sent = true;
+        this.child.stdin.end();
+        // The build is done with it: this process need not wait for it to exit.
+        this.child.unref();
+        this.child.stdin.unref?.();
+    }
+}
+/**
+ * `prepareExecutableInput` in the frontend process, with the LLVM text passed on as its file. The
+ * process's frontend inputs join `frontendInputs` and its warnings `warningSink`. If it fails, the
+ * input is prepared here, so the build reports the same errors.
+ */
+async function prepareExecutableInputInChild(frontendProcess, entryPath, opts, ffi, buildPlatform, timing, timingClock, frontendInputs, warningSink) {
+    await mkdir(opts.outDir, { recursive: true });
+    const requestPath = privateSiblingPath(join(opts.outDir, "frontend-request.json"), "frontend");
+    const resultPath = privateSiblingPath(join(opts.outDir, "frontend-result.json"), "frontend");
+    let result = { kind: "failed" };
+    try {
+        const request = {
+            entryPath,
+            opts,
+            buildPlatform,
+            timing: timingClock,
+            provenance: provenanceSources(),
+        };
+        await writeFile(requestPath, JSON.stringify(request), { mode: 0o600 });
+        const exitCode = await frontendProcess.run(requestPath, resultPath);
+        if (exitCode === 0)
+            result = JSON.parse(await readFile(resultPath, "utf8"));
+    }
+    catch {
+        result = { kind: "failed" };
+    }
+    finally {
+        await rm(requestPath, { force: true });
+        await rm(resultPath, { force: true });
+    }
+    if (result.kind === "failed")
+        return prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timing, warningSink);
+    timing("frontend-process");
+    for (const probe of result.frontend.probes)
+        frontendInputs.record(probe);
+    if (!result.frontend.stable)
+        frontendInputs.markUnstable();
+    const sourceTexts = new Map(result.sourceTexts);
+    if (warningSink !== undefined && result.warnings.length > 0) {
+        warningSink.warnings = result.warnings;
+        warningSink.sourceTexts = sourceTexts;
+    }
+    if (result.kind === "diagnostics")
+        return { ok: false, diagnostics: result.diagnostics, sourceTexts };
+    return {
+        llvmSource: { file: result.nativeInputPath, bytes: result.llvmBytes },
+        llvmPath: result.llvmPath,
+        llvmSourcePath: result.nativeInputPath,
+        irPath: result.irPath,
+        irSourcePath: result.irSourcePath,
+        nativeFeatures: result.nativeFeatures,
+        programSplit: null,
+        sourceTexts,
+    };
+}
+/**
+ * The frontend process (frontend-process.ts): prepares the executable input of the request at
+ * `requestPath` as `compileTracked` would in-process, and writes what it prepared, without the LLVM
+ * text, to `resultPath`.
+ */
+export async function runFrontendProcess(requestPath, resultPath) {
+    const request = JSON.parse(await readFile(requestPath, "utf8"));
+    clearCompileSessionCaches();
+    setProvenanceSources(request.provenance);
+    const frontendInputs = new FrontendInputTracker();
+    const warnings = { warnings: [], sourceTexts: null };
+    let result = { kind: "failed" };
+    try {
+        let ffi = null;
+        if (request.opts.ffiProfilePath !== undefined) {
+            const loaded = loadFfiProfile(resolve(request.opts.ffiProfilePath));
+            if (!loaded.ok)
+                throw new InternalCompilerError("the FFI profile could not be reloaded");
+            ffi = loaded.profile;
+        }
+        const prepared = await frontendInputs.run(() => prepareExecutableInput(request.entryPath, request.opts, ffi, request.buildPlatform, compilationTiming(request.timing), warnings));
+        const frontend = frontendInputs.snapshot();
+        if (!("ok" in prepared)) {
+            if (isLlvmFile(prepared.llvmSource))
+                throw new InternalCompilerError("in-process preparation returned LLVM text as a file");
+            result = {
+                kind: "prepared",
+                llvmPath: prepared.llvmPath,
+                nativeInputPath: prepared.llvmSourcePath,
+                llvmBytes: llvmInputBytes(prepared.llvmSource),
+                irPath: prepared.irPath,
+                irSourcePath: prepared.irSourcePath,
+                nativeFeatures: prepared.nativeFeatures,
+                sourceTexts: [...prepared.sourceTexts],
+                warnings: warnings.warnings,
+                frontend,
+            };
+        }
+        else if (!prepared.ok) {
+            result = {
+                kind: "diagnostics",
+                diagnostics: prepared.diagnostics,
+                sourceTexts: [...prepared.sourceTexts],
+                warnings: warnings.warnings,
+                frontend,
+            };
+        }
+    }
+    catch {
+        result = { kind: "failed" };
+    }
+    await writeFile(resultPath, JSON.stringify(result), { mode: 0o600 });
+}
+async function compileTracked(entryPath, opts, frontendInputs, warningSink, frontendProcess) {
     const timing = compilationTiming();
+    const timingStart = Date.now();
     entryPath = resolve(entryPath);
     const outputKind = opts.outputKind ?? "exe";
     if ((opts.backend !== undefined && opts.backend !== "llvm") ||
@@ -650,22 +926,35 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
             sourceTexts: new Map(),
         };
     }
+    const profileRefusal = nativeProfileRefusal({
+        ...opts,
+        outputKind,
+        optimization: opts.optimization ?? "release",
+        sanitize: opts.sanitize ?? false,
+        platform: buildPlatform,
+    });
+    let profile;
+    try {
+        if (profileRefusal !== null)
+            throw new Error(profileRefusal);
+        profile = await readNativeProfile(opts);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            diagnostics: [
+                nativeCodegenDiag("SC3002", err instanceof Error ? err.message : String(err), entryPath),
+            ],
+            sourceTexts: new Map(),
+        };
+    }
     const cacheRoot = outputKind === "exe" && provenanceSources() === null
         ? await prepareBuildCacheRoot(buildCacheRoot())
         : null;
     let earlyCacheOptions = null;
     if (outputKind === "exe") {
         const helperObjectRoute = opts.nativeProgramObject === true || usesPrecompiledRuntimePack(opts, "llvm");
-        // Package content and native driver discovery are independent inputs to
-        // the same cache key. Start both before waiting so edits do not pay their
-        // filesystem and subprocess latency serially.
-        const [implementation, nativeEnvironment] = await Promise.all([
-            compilerImplementationIdentity(),
-            helperObjectRoute
-                ? executableLinkerEnvironmentFingerprint(process.env, nativeCodegenTarget()?.defaultLinker)
-                : executableNativeEnvironmentFingerprint(),
-        ]);
-        earlyCacheOptions = {
+        const routeOptions = {
             entryPath,
             outDir: opts.outDir,
             outPath: opts.outPath,
@@ -676,6 +965,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
             ...(opts.strip ? { strip: true } : {}),
             ...(opts.windowsSubsystem === "gui" ? { windowsSubsystem: "gui" } : {}),
             ...(opts.detachedExit === true ? { detachedExit: true } : {}),
+            ...(profile === undefined ? {} : { profile: nativeProfileKey(profile) }),
             ...checkerField(),
             ...(youngNurseryRequested() ? { youngNursery: true } : {}),
             npmStatic: opts.npmStatic ?? null,
@@ -692,8 +982,25 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
                     ? resolvePlatformLinker(process.env, nativeCodegenTarget()?.defaultLinker)
                     : (process.env["SCRIPTC_CC"] ?? "clang"),
             ],
-            nativeEnvironment,
             nodeVersion: process.version,
+        };
+        // The frontend process prepares the first build of an invocation (preparesInChildProcess).
+        // Started here, it loads the compiler while this process computes the rest of the cache key.
+        if (frontendProcess !== undefined &&
+            !(await hasEarlyExecutableNativeBuild(cacheRoot, routeOptions)))
+            frontendProcess.start();
+        // Package content and native driver discovery are independent inputs to
+        // the same cache key. Start both before waiting so edits do not pay their
+        // filesystem and subprocess latency serially.
+        const [implementation, nativeEnvironment] = await Promise.all([
+            compilerImplementationIdentity(),
+            helperObjectRoute
+                ? executableLinkerEnvironmentFingerprint(process.env, nativeCodegenTarget()?.defaultLinker)
+                : executableNativeEnvironmentFingerprint(),
+        ]);
+        earlyCacheOptions = {
+            ...routeOptions,
+            nativeEnvironment,
             implementation: implementation.digest,
             implementationDependencies: implementation.dependencies,
         };
@@ -706,6 +1013,12 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
         if (earlyCacheOptions === null) {
             throw new InternalCompilerError("executable cache hit without executable cache options");
         }
+        // A cached build repeats its performance warning (SC6101): the code it
+        // names is just as untyped as when it was built.
+        if (warningSink !== undefined && earlyHit.performance !== undefined) {
+            warningSink.warnings = earlyHit.performance;
+            warningSink.sourceTexts = new Map();
+        }
         const executableCacheOptions = earlyCacheOptions;
         // Route/proof metadata is independently evictable. A full-compiler
         // fallback that still finds the validated payload repairs that lightweight
@@ -728,39 +1041,64 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
                 ...(earlyHit.irPath === undefined ? {} : { irPath: earlyHit.irPath }),
             };
         }
-        let nativeInputPath = earlyHit.llvmPath;
+        // The build's private copies of the cached LLVM text and IR (BuildSources).
+        const hitSources = {
+            llvmPath: earlyHit.llvmPath,
+            llvmSourcePath: earlyHit.llvmSourcePath ?? earlyHit.llvmPath,
+            irPath: earlyHit.irPath,
+            irSourcePath: earlyHit.irSourcePath,
+            llvmPathCurrent: earlyHit.llvmPathCurrent,
+            irPathCurrent: earlyHit.irPathCurrent,
+        };
+        // What the native build compiles and the cache publishes: hitSources, or their staged copies.
+        let nativeSources = hitSources;
+        let stagedDir = null;
+        let nativeInputPath = hitSources.llvmSourcePath;
         let nativeProgramObject = null;
         const useRuntimePack = opts.nativeProgramObject === true ||
             usesPrecompiledRuntimePack(opts, earlyHit.native.backend);
-        if (useRuntimePack) {
-            if (earlyHit.native.backend !== "llvm") {
-                throw new InternalCompilerError("native program-object cache hit restored a non-LLVM translation unit");
+        try {
+            if (useRuntimePack) {
+                if (earlyHit.native.backend !== "llvm") {
+                    throw new InternalCompilerError("native program-object cache hit restored a non-LLVM translation unit");
+                }
+                try {
+                    nativeProgramObject = await emitNativeProgramObject(entryPath, opts, 
+                    // A large program's LLVM exceeds the engine's string limit as one
+                    // string; the emitter takes it in parts, as on a cold build.
+                    await readTextParts(hitSources.llvmSourcePath), profile);
+                    nativeInputPath = nativeProgramObject.linkPath;
+                }
+                catch (err) {
+                    if (!(err instanceof NativeCodegenError))
+                        throw err;
+                    return {
+                        ok: false,
+                        diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)],
+                        sourceTexts: new Map(),
+                    };
+                }
             }
-            try {
-                nativeProgramObject = await emitNativeProgramObject(entryPath, opts, await readFile(earlyHit.llvmPath, "utf8"), earlyHit.native);
-                nativeInputPath = nativeProgramObject.linkPath;
+            else {
+                const staged = await stageDriverBuildSources(hitSources);
+                stagedDir = staged.dir;
+                nativeSources = staged.sources;
+                nativeInputPath = nativeSources.llvmSourcePath;
             }
-            catch (err) {
-                if (!(err instanceof NativeCodegenError))
-                    throw err;
-                return {
-                    ok: false,
-                    diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)],
-                    sourceTexts: new Map(),
-                };
-            }
-        }
-        try {
             await compileExecutableNative(earlyHit.native, nativeInputPath, opts.outPath, opts.sanitize ?? false, ffi, opts.windowsSubsystem, opts.strip, null, nativeProgramObject?.dependencies, opts.nativeProgramObject === true
                 ? undefined
                 : async ({ dependencies }) => {
                     await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
                         ...earlyHit,
+                        llvmPath: nativeSources.llvmSourcePath,
+                        ...(nativeSources.irSourcePath === undefined
+                            ? {}
+                            : { irPath: nativeSources.irSourcePath }),
                         executableRestored: true,
                         nativeDependencies: dependencies,
                         frontend: earlyHit.frontend,
                     });
-                }, nativeProgramObject?.partitionPaths);
+                }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, hitSources.llvmPath);
             if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
                 await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath);
             }
@@ -788,6 +1126,10 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
             if (nativeProgramObject !== null) {
                 await removeNativeProgramObject(nativeProgramObject.linkPath, nativeProgramObject.partitionPaths);
             }
+            if (stagedDir === null)
+                await installBuildSources(hitSources);
+            else
+                await rm(stagedDir, { recursive: true, force: true });
         }
         await pruneBuildCache(cacheRoot);
         return {
@@ -805,10 +1147,22 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
         };
     }
     timing("executable-cache-miss");
-    const prepared = await prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timing, warningSink);
+    const prepared = frontendProcess?.started === true
+        ? await prepareExecutableInputInChild(frontendProcess, entryPath, opts, ffi, buildPlatform, timing, { start: timingStart, previous: Date.now() }, frontendInputs, warningSink)
+        : await prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timing, warningSink);
     if ("ok" in prepared)
         return prepared;
-    const { llvmSource, llvmPath, irPath, nativeFeatures, programSplit, sourceTexts } = prepared;
+    const buildSources = {
+        llvmPath: prepared.llvmPath,
+        llvmSourcePath: prepared.llvmSourcePath,
+        irPath: prepared.irPath,
+        irSourcePath: prepared.irSourcePath,
+    };
+    const { llvmSource, llvmPath, irPath } = prepared;
+    const { nativeFeatures, programSplit, sourceTexts } = prepared;
+    // What the native build compiles and the cache publishes: buildSources, or their staged copies.
+    let { llvmSourcePath, irSourcePath } = buildSources;
+    let stagedDir = null;
     const backend = "llvm";
     await mkdir(dirname(opts.outPath), { recursive: true });
     if (earlyCacheOptions === null) {
@@ -824,8 +1178,9 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
                 throw new InternalCompilerError("native program-object validation requires the LLVM backend");
             }
             try {
-                nativeProgramObject = await emitNativeProgramObject(entryPath, opts, llvmSource, nativeFeatures);
+                nativeProgramObject = await emitNativeProgramObject(entryPath, opts, llvmSource, profile);
                 timing("native-object");
+                await recordEarlyExecutableNativeBuild(cacheRoot, executableCacheOptions).catch(() => undefined);
             }
             catch (err) {
                 if (!(err instanceof NativeCodegenError))
@@ -837,23 +1192,39 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
                 };
             }
         }
-        await compileExecutableNative(nativeFeatures, nativeProgramObject?.linkPath ?? llvmPath, opts.outPath, opts.sanitize ?? false, ffi, opts.windowsSubsystem, opts.strip, programSplit, nativeProgramObject?.dependencies, opts.nativeProgramObject === true
+        else {
+            const staged = await stageDriverBuildSources(buildSources);
+            stagedDir = staged.dir;
+            ({ llvmSourcePath, irSourcePath } = staged.sources);
+        }
+        await compileExecutableNative(nativeFeatures, nativeProgramObject?.linkPath ?? llvmSourcePath, opts.outPath, opts.sanitize ?? false, ffi, opts.windowsSubsystem, opts.strip, programSplit, nativeProgramObject?.dependencies, opts.nativeProgramObject === true
             ? undefined
             : async ({ dependencies }) => {
                 await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
-                    llvmPath,
+                    llvmPath: llvmSourcePath,
                     native: nativeFeatures,
                     executableRestored: true,
                     nativeDependencies: dependencies,
                     frontend: frontendInputs.snapshot(),
-                    ...(irPath === undefined ? {} : { irPath }),
+                    ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
+                    ...performanceWarnings(warningSink),
                 });
                 publishedExecutable = true;
-            }, nativeProgramObject?.partitionPaths);
+            }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, llvmPath);
         timing("native-link");
         if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
             await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath);
         }
+        if (!publishedExecutable) {
+            await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
+                llvmPath: llvmSourcePath,
+                native: nativeFeatures,
+                executableRestored: false,
+                frontend: frontendInputs.snapshot(),
+                ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
+                ...performanceWarnings(warningSink),
+            }).catch(() => undefined);
+        }
     }
     catch (err) {
         if (err instanceof RuntimePackError) {
@@ -874,15 +1245,10 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink) {
         if (nativeProgramObject !== null) {
             await removeNativeProgramObject(nativeProgramObject.linkPath, nativeProgramObject.partitionPaths);
         }
-    }
-    if (!publishedExecutable) {
-        await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
-            llvmPath,
-            native: nativeFeatures,
-            executableRestored: false,
-            frontend: frontendInputs.snapshot(),
-            ...(irPath === undefined ? {} : { irPath }),
-        }).catch(() => undefined);
+        if (stagedDir === null)
+            await installBuildSources(buildSources);
+        else
+            await rm(stagedDir, { recursive: true, force: true });
     }
     await pruneBuildCache(cacheRoot);
     timing("complete");
@@ -922,6 +1288,7 @@ function libraryNativeFeatures(mod, backend) {
         copying: features.copying,
         textDecoderLegacy: features.legacyTextDecoder,
         dynInvoke: features.dynInvoke,
+        ...(features.dynBuffer ? { dynBuffer: true } : {}),
         ...(features.dynTier ? { dynTier: true } : {}),
         ...(mod.lib?.identity !== undefined ? { buildId: mod.lib.identity.buildId } : {}),
     };
@@ -996,6 +1363,7 @@ async function compileLibraryNative(profile, llvmPath, archivePath, sanitize, fe
         copying: features.copying,
         textDecoderLegacy: features.textDecoderLegacy,
         dynInvoke: features.dynInvoke,
+        ...(features.dynBuffer === true ? { dynBuffer: true } : {}),
         ...(features.dynTier === true ? { dynTier: true } : {}),
     };
     if (packTarget !== null)