@scriptc/compiler 0.4.5 → 0.4.6

package/dist/index.js

@@ -1,7 +1,13 @@
+import { createRequire } from "node:module";
+import { setShapeOverlayMemoDir, shapeOverlayEnabled } from "./frontend/shape-inference/index.js";
+import { nodeFrontendServices } from "./frontend/services-node.js";
+import { runTypePatchCommand, } from "./frontend/type-patches/command.js";
 import { optimizationField } from "./backend/optimization.js";
 import { targetCpuField, targetCpuTargetRefusal } from "./backend/target-cpu.js";
 import { compilationTiming } from "./timing.js";
 import { prepareExecutableModule } from "./executable/prepare.js";
+import { nodeIslandOptionsKey } from "./node-islands/policy.js";
+import { setIslandResolver } from "./node-islands/resolve.js";
 import { prepareLibrary, libraryLocalizeSymbols, libraryWasmExports, libraryWasmRefusal, } from "./library/prepare.js";
 import { analyzeWithFrontend } from "./frontend/analysis.js";
 import { checkerCacheIdentity } from "./frontend/ts7/checker-backend.js";
@@ -13,15 +19,17 @@ import { llvmRefusalDiag, targetRefusalDiag } from "./backend/target-diagnostics
 import { compilePackedLibrary } from "./backend/library-pack.js";
 import { node24FetchCompatProfile } from "./compat/fetch-profile.js";
 import { libFnSignatures } from "./ir/builtin-signatures.js";
+import { parseFunctionLayout } from "./backend/llvm/function-layout.js";
 import { InternalCompilerError } from "./errors.js";
 import { frontendProcessExecArgv } from "./frontend-process-args.js";
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } 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 { gunzipSync } from "node:zlib";
 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";
@@ -30,16 +38,19 @@ import { inlineRcOption } from "./backend/llvm/shapes.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 { nativeCodegenTarget, nativeCodegenTargetRefusal, staticLinkRefusal, } from "./backend/targets.js";
 import { windowsSubsystemLinkerArgs } from "./backend/targets.js";
 import { createNativeLinkInfo } from "./backend/native-link-info.js";
 import { RuntimePackError } from "./backend/runtime-pack.js";
 import { createNativeLinkPlan } from "./backend/link-plan.js";
-import { nativeProfileKey, nativeProfileRefusal, } from "./backend/native-profile.js";
+import { nativeProfileKey, nativeProfileLayout, nativeProfileRefusal, profileBlocksPath, profileHasContextCounts, recordProfileBlocksPath, } from "./backend/native-profile.js";
 import { executableLinkerEnvironmentFingerprint, linkNativeExecutable, platformLinkerSupportsPersistentCache, resolvePlatformLinker, } from "./backend/linker.js";
 import { splitLlvmLibraryProgram, splitLlvmProgram, splitLlvmProgramFile, } from "./backend/llvm/split.js";
 import { emitLibraryIdentityLines, replaceLibraryIdentity, stripLibraryIdentity, } from "./backend/library-identity-markers.js";
-import { ffiNativeBuildDiag, iceDiag, nativeCodegenDiag, } from "./diagnostics/diagnostic.js";
+import { ffiNativeBuildDiag, iceDiag, nativeCodegenDiag, nodeIslandNodeDiag, nodeIslandModuleDiag, isTypePatchCode, } from "./diagnostics/diagnostic.js";
+import { libnodeCacheKey, libnodeProbePack, libnodeRecord } from "./node-islands/libnode.js";
+import { placeNodeIslandModules, readNodeIslandModules } from "./node-islands/modules.js";
+import { finalizeDeferredIslands } from "./node-islands/snapshot.js";
 import { loadLibraryProfile } from "./library/library-profile.js";
 import { clearFenceEvalCaches, decorateLibraryRefusals } from "./library/fence-eval.js";
 import { canonicalModuleGraph, clearSidecarCaches, compilerReleaseVersion, libraryIdentityHashes, updateSidecarIdentity, } from "./library/sidecar.js";
@@ -56,6 +67,8 @@ 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 { heapCensusRequested } from "./backend/llvm/heap-census.js";
+import { representationReportPath } from "./backend/llvm/repr-report.js";
 import { FrontendInputTracker, trackedReadFile, } from "./frontend/input-tracker.js";
 import { libraryFrontendImplementationFingerprint, publishEarlyLibraryCache, readEarlyLibraryCache, readSemanticLibraryCache, } from "./library/library-cache.js";
 import { hasEarlyExecutableNativeBuild, publishEarlyExecutableCache, publishEarlyExecutableRoute, readEarlyExecutableCache, recordEarlyExecutableNativeBuild, } from "./executable/executable-cache.js";
@@ -67,6 +80,10 @@ 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";
+/** `scriptc types patch|list` with the Node frontend's parser. */
+export async function typePatches(request) {
+    return runTypePatchCommand(request, (path, text, kind) => nodeFrontendServices().parse(path, text, kind));
+}
 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";
@@ -147,6 +164,9 @@ export async function analyzeCached(entryPath, opts = {}) {
     }
     return result;
 }
+// Island code resolves through Node (node-islands/resolve.ts; the
+// self-hosted compiler builds no islands).
+setIslandResolver((fromFile, spec) => createRequire(fromFile).resolve(spec));
 const nodeFrontend = (entry, npmStatic, externalTypes, libraryNpmStatic, options) => runFrontend(entry, loadProgram, npmStatic, externalTypes, libraryNpmStatic, options);
 /** The checker's part of the executable cache key (`checkerCacheIdentity`), as the CLI's startup route computes it. */
 function checkerField() {
@@ -162,6 +182,11 @@ function clearCompileSessionCaches() {
 }
 export async function compile(entryPath, opts) {
     clearCompileSessionCaches();
+    // `shapeOverlay` reaches the frontend (and its child process) through
+    // the environment the overlay reads.
+    const overlayEnv = process.env["SCRIPTC_SHAPE_OVERLAY"];
+    if (opts.shapeOverlay !== undefined)
+        process.env["SCRIPTC_SHAPE_OVERLAY"] = opts.shapeOverlay ? "1" : "0";
     const frontendInputs = new FrontendInputTracker();
     const warnings = { warnings: [], sourceTexts: null };
     // compileTracked starts it for a build with no earlier build of the same invocation.
@@ -173,14 +198,43 @@ export async function compile(entryPath, opts) {
     finally {
         setLibDiagnosticsStore(null);
         frontendProcess?.release();
+        if (opts.shapeOverlay !== undefined) {
+            if (overlayEnv === undefined)
+                delete process.env["SCRIPTC_SHAPE_OVERLAY"];
+            else
+                process.env["SCRIPTC_SHAPE_OVERLAY"] = overlayEnv;
+        }
     }
 }
+/** The package.json texts type patch warnings point into, re-read for a
+ * cache hit's code frames (performance warnings need none). */
+function cachedWarningSources(warnings) {
+    const texts = new Map();
+    for (const w of warnings) {
+        if (!isTypePatchCode(w.code) || texts.has(w.loc.file))
+            continue;
+        try {
+            texts.set(w.loc.file, readFileSync(w.loc.file, "utf8"));
+        }
+        catch {
+            // The frame is omitted; the message stands alone.
+        }
+    }
+    return texts;
+}
 /** 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));
+    // Type patch warnings (SC8030–SC8033) describe the same unchanged inputs,
+    // so a hit repeats them too.
+    const performance = (sink?.warnings ?? []).filter((d) => isPerformanceCode(d.code) || isTypePatchCode(d.code));
     return performance.length === 0 ? {} : { performance };
 }
+/** The profile match of a --profile-use build's program object, for its
+ * artifact and its executable cache entry, which a cache hit reports again. */
+function profileMatchField(object) {
+    return object?.profileMatch === undefined ? {} : { profileMatch: object.profileMatch };
+}
 function withCompileWarnings(result, sink) {
     if (!result.ok || sink.warnings.length === 0)
         return result;
@@ -204,17 +258,17 @@ function assertCompileResultCompatibility(result) {
     }
 }
 void assertCompileResultCompatibility;
-function executableNativeFeatures(mod, backend, optimization) {
+function executableNativeFeatures(mod, backend, optimization, largePages) {
     return {
         backend,
         ...optimizationField(optimization),
-        ...executableLinkFeatures(mod),
+        ...executableLinkFeatures(mod, largePages),
     };
 }
-async function compileExecutableNative(features, llvmPath, outPath, sanitize, ffi, windowsSubsystem, strip, programSplit = null, programObjectDependencies = [], onArtifactReady, programPartitions = [], profileGenerate = false, 
+async function compileExecutableNative(features, llvmPath, outPath, sanitize, ffi, windowsSubsystem, strip, staticLink = false, 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) {
+llvmVisiblePath, profileLayout = false, hugeText = true) {
     const programIsObject = /\.(?:o|obj)$/.test(llvmPath);
     const runtimePackTarget = programIsObject && !sanitize ? nativeCodegenTarget() : null;
     if (runtimePackTarget !== null) {
@@ -227,8 +281,11 @@ llvmVisiblePath) {
             ffi,
             optimization: features.optimization ?? "release",
             ...(strip ? { strip: true } : {}),
+            ...(staticLink ? { staticLink: true } : {}),
             ...(windowsSubsystem === undefined ? {} : { windowsSubsystem }),
             ...(profileGenerate ? { profileGenerate: true } : {}),
+            ...(profileLayout ? { profileLayout: true } : {}),
+            ...(hugeText ? {} : { hugeText: false }),
             programObjectDependencies,
         });
         const cacheableLinker = onArtifactReady !== undefined &&
@@ -250,6 +307,8 @@ llvmVisiblePath) {
             : null);
     if (programIsObject)
         throw new InternalCompilerError("program objects must link against a precompiled runtime pack");
+    if (staticLink)
+        throw new InternalCompilerError("--static executables link against a precompiled runtime pack");
     await compileExternalC({
         ...(llvmVisiblePath === undefined || llvmVisiblePath === llvmPath
             ? { cPath: llvmPath }
@@ -275,7 +334,9 @@ llvmVisiblePath) {
         ...(features.wasm ? { wasm: true } : {}),
         ...(features.warningReplace ? { warningReplace: true } : {}),
         ...(features.stdioExtended ? { stdioExtended: true } : {}),
+        ...(features.nodeIsland ? { nodeIsland: true } : {}),
         ...(features.moduleNamespace ? { moduleNamespace: true } : {}),
+        ...(features.moduleNamespaceDyn ? { moduleNamespaceDyn: true } : {}),
         zlib: features.zlib,
         ...(features.brotli ? { brotli: true } : {}),
         assert: features.assert,
@@ -286,15 +347,24 @@ llvmVisiblePath) {
         ...(features.dynTier ? { dynTier: true } : {}),
         ...(features.streamDyn ? { streamDyn: true } : {}),
         ...(features.handleProps ? { handleProps: true } : {}),
+        ...(features.childLifecycle ? { childLifecycle: true } : {}),
         ...(features.declAdopt ? { declAdopt: true } : {}),
+        ...(features.typeOrigins ? { typeOrigins: true } : {}),
         ...(features.dynForAwait ? { dynForAwait: true } : {}),
         ...(features.eventsOnceSignal ? { eventsOnceSignal: true } : {}),
+        ...(features.mime ? { mime: true } : {}),
+        ...(features.largePages ? { largePages: true } : {}),
+        ...(features.webStreams ? { webStreams: true } : {}),
+        ...(features.abortSignal ? { abortSignal: true } : {}),
+        ...(features.utilTiming ? { utilTiming: true } : {}),
         ...(features.dynBuffer ? { dynBuffer: true } : {}),
         ...(features.builtinValues ? { builtinValues: true } : {}),
+        ...(features.computedRequire ? { computedRequire: true } : {}),
         events: features.events,
         emitter: features.emitter,
         symbol: features.symbol,
         bigint: features.bigint,
+        ...(features.bigstats ? { bigstats: true } : {}),
         searchParams: features.searchParams,
         qs: features.qs,
         utilPromisify: features.utilPromisify,
@@ -344,7 +414,8 @@ async function emitNativeProgramObject(entryPath, opts, llvm, profile) {
     // The validated program-object artifact is a single object by contract.
     const target = nativeCodegenTarget();
     const llvmBytes = llvmInputBytes(llvm);
-    const partitions = opts.nativeProgramObject === true || target === null ? 1 : nativeProgramPartitions(llvmBytes);
+    const single = opts.nativeProgramObject === true || target === null;
+    const partitions = single ? 1 : nativeProgramPartitions(llvmBytes, opts.optimization === "dev");
     try {
         const artifact = await emitNativeArtifact({
             outputPath: linkPath,
@@ -372,13 +443,12 @@ async function emitNativeProgramObject(entryPath, opts, llvm, profile) {
 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. */
+/** The request's profile. An indexed profile and the block-count file beside
+ * it are read here so every cache keys their bytes. */
 async function readNativeProfile(opts) {
-    if (opts.profileGenerate !== undefined)
-        return { generate: opts.profileGenerate };
+    const generate = opts.profileGenerate;
     if (opts.profileUse === undefined)
-        return undefined;
+        return generate === undefined ? undefined : { generate };
     const path = resolve(opts.profileUse);
     let bytes;
     try {
@@ -387,7 +457,53 @@ async function readNativeProfile(opts) {
     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") } };
+    const blocksPath = profileBlocksPath(path);
+    const blockBytes = existsSync(blocksPath) ? await readFile(blocksPath) : null;
+    const use = {
+        path,
+        digest: createHash("sha256").update(bytes).digest("hex"),
+        contextSensitive: profileHasContextCounts(bytes),
+        ...(blockBytes === null
+            ? {}
+            : {
+                blocks: {
+                    path: blocksPath,
+                    digest: createHash("sha256").update(blockBytes).digest("hex"),
+                },
+            }),
+    };
+    const recordBlocks = recordProfileBlocksPath(process.env);
+    return {
+        ...(generate === undefined ? {} : { generate }),
+        use,
+        ...(recordBlocks === undefined ? {} : { recordBlocks: resolve(recordBlocks) }),
+    };
+}
+/** The digest of the request's function layout file, which keys the
+ * executable cache: the layout changes the code's order, not its frontend
+ * input. */
+async function functionLayoutKey(opts) {
+    if (opts.functionLayout === undefined)
+        return undefined;
+    const path = resolve(opts.functionLayout);
+    let bytes;
+    try {
+        bytes = await readFile(path);
+    }
+    catch (err) {
+        throw new Error(`cannot read function layout ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return createHash("sha256").update(bytes).digest("hex");
+}
+/** The request's function layout. */
+async function readFunctionLayout(opts) {
+    if (opts.functionLayout === undefined)
+        return {};
+    const path = resolve(opts.functionLayout);
+    const bytes = await readFile(path);
+    return {
+        functionLayout: parseFunctionLayout((path.endsWith(".gz") ? gunzipSync(bytes) : bytes).toString("utf8")),
+    };
 }
 function usesPrecompiledRuntimePack(opts, backend) {
     if (backend !== "llvm" || opts.sanitize === true)
@@ -405,6 +521,52 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
     if (!prepared.ok)
         return prepared;
     const { mod, sourceTexts } = prepared;
+    // Calls into Node record the libnode pack an executable loads at run
+    // time. IR, LLVM and object outputs need no pack: their record stays
+    // empty, and SCRIPTC_LIBNODE supplies the pack when such a program runs.
+    if (mod.nodeIsland !== undefined) {
+        if (!moduleRuntimeFeatures(mod).nodeIsland) {
+            delete mod.nodeIsland;
+        }
+        else if (outputKind === "exe") {
+            const recorded = libnodeRecord(opts.libnode, opts.outPath, process.env, dirname(entryPath));
+            if (typeof recorded === "string")
+                return { ok: false, diagnostics: [nodeIslandNodeDiag(recorded, entryPath)], sourceTexts };
+            mod.nodeIsland = { ...mod.nodeIsland, ...recorded };
+            // Deferred island modules (scope-B NI-7): probed in the same pack.
+            finalizeDeferredIslands(mod, entryPath, libnodeProbePack(opts.libnode, process.env, dirname(entryPath)));
+        }
+        else {
+            // IR, LLVM and object outputs have no pack to probe with: eager.
+            finalizeDeferredIslands(mod, entryPath, null);
+        }
+    }
+    // The island module tree ships with the program: beside the executable
+    // with --libnode=beside, else inside it (node-islands/modules.ts).
+    let nodeIslandModuleData;
+    const islandModules = mod.nodeIsland?.modules;
+    if (islandModules !== undefined && outputKind !== "ir") {
+        if (outputKind === "exe" && opts.libnode === "beside") {
+            const problem = placeNodeIslandModules(islandModules, `${opts.outPath}.libnode/modules`);
+            if (problem !== null)
+                return {
+                    ok: false,
+                    diagnostics: [nodeIslandModuleDiag(problem, { file: entryPath, start: 0, end: 0 })],
+                    sourceTexts,
+                };
+            islandModules.location = `$ORIGIN/${basename(opts.outPath)}.libnode/modules`;
+        }
+        else {
+            const data = readNodeIslandModules(islandModules);
+            if (typeof data === "string")
+                return {
+                    ok: false,
+                    diagnostics: [nodeIslandModuleDiag(data, { file: entryPath, start: 0, end: 0 })],
+                    sourceTexts,
+                };
+            nodeIslandModuleData = data;
+        }
+    }
     if (warningSink !== undefined && prepared.warnings.length > 0) {
         warningSink.warnings = prepared.warnings;
         warningSink.sourceTexts = sourceTexts;
@@ -426,16 +588,20 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
             llvm = emitLlvmModuleSource(mod, {
                 targetTriple: process.env["SCRIPTC_TARGET"] ?? "",
                 ...debugOptions,
+                ...(await readFunctionLayout(opts)),
                 pointerBits: buildPlatform === "wasi" ? 32 : 64,
                 wasi: buildPlatform === "wasi",
                 runtimeAbiMarker: outputKind === "obj",
                 // Textual output shows the code an executable gets; objects keep
                 // the pending flag, since their link may not add an unwinder.
                 unwindAbi: buildPlatform === "linux" && outputKind !== "obj",
+                ...(opts.exceptions === "rare" ? { rareExceptions: true } : {}),
                 objectAudit: opts.sanitize === true,
+                sanitizeAttributes: opts.sanitize === true,
                 lowRegion: lowRegionTarget(buildPlatform, opts.sanitize === true),
                 ...(opts.sanitize === true ? { wasmBoundsChecks: true } : {}),
                 ...inlineRcOption(opts.optimization, opts.sanitize === true),
+                ...(nodeIslandModuleData === undefined ? {} : { nodeIslandModuleData }),
                 ...targetCpuField(opts.targetCpu),
             });
         }
@@ -482,7 +648,7 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
                     nativeLinkInfo: await createNativeLinkInfo({
                         programObject: opts.outPath,
                         target,
-                        features: executableNativeFeatures(mod, "llvm", opts.optimization ?? "release"),
+                        features: executableNativeFeatures(mod, "llvm", opts.optimization ?? "release", opts.largePages === true),
                         ffi,
                         optimization: opts.optimization ?? "release",
                     }),
@@ -502,16 +668,22 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         llvmSource = emitLlvmModuleSource(mod, {
             targetTriple: process.env["SCRIPTC_TARGET"] ?? "",
             ...debugOptions,
+            ...(await readFunctionLayout(opts)),
             pointerBits: buildPlatform === "wasi" ? 32 : 64,
             wasi: buildPlatform === "wasi",
             runtimeAbiMarker: useRuntimePack,
             unwindAbi: buildPlatform === "linux",
             objectAudit: opts.sanitize === true,
+            sanitizeAttributes: opts.sanitize === true,
             lowRegion: lowRegionTarget(buildPlatform, opts.sanitize === true),
+            timing,
             ...(opts.sanitize === true ? { wasmBoundsChecks: true } : {}),
             ...inlineRcOption(opts.optimization, opts.sanitize === true),
             ...(opts.detachedExit === true ? { detachedExit: true } : {}),
+            ...(nodeIslandModuleData === undefined ? {} : { nodeIslandModuleData }),
+            ...(opts.exceptions === "rare" ? { rareExceptions: true } : {}),
             ...targetCpuField(opts.targetCpu),
+            ...(opts.cpuDispatch === true ? { cpuDispatch: true } : {}),
         });
     }
     catch (err) {
@@ -529,7 +701,7 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         irSourcePath = privateSiblingPath(irPath, "ir");
         await writeTextParts(irSourcePath, serializeModuleParts(mod, compilerOwnedFileRoots()));
     }
-    const nativeFeatures = executableNativeFeatures(mod, backend, opts.optimization ?? "release");
+    const nativeFeatures = executableNativeFeatures(mod, backend, opts.optimization ?? "release", opts.largePages === true);
     timing("link-features");
     const programSplit = !useRuntimePack &&
         backend === "llvm" &&
@@ -600,6 +772,14 @@ async function stageDriverBuildSources(sources) {
  * (`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.
  */
+/** The shape overlay's memo directory for the current executable build
+ * (frontend/shape-inference/memo.ts): per compiler, in the build cache. */
+let shapeOverlayMemo = null;
+function shapeOverlayMemoDir(cacheRoot, implementation) {
+    return cacheRoot === null
+        ? null
+        : join(cacheRoot, "shape-overlay-v1", implementation.slice(0, 24));
+}
 const frontendProcessEntry = fileURLToPath(new URL("./frontend-process.js", import.meta.url));
 /**
  * Whether `prepareExecutableInputInChild` may prepare this build: optimized executables, when the
@@ -681,6 +861,7 @@ async function prepareExecutableInputInChild(frontendProcess, entryPath, opts, f
             buildPlatform,
             timing: timingClock,
             provenance: provenanceSources(),
+            shapeOverlayMemo,
         };
         await writeFile(requestPath, JSON.stringify(request), { mode: 0o600 });
         const exitCode = await frontendProcess.run(requestPath, resultPath);
@@ -743,8 +924,13 @@ function configureLibDiagnostics(root) {
 }
 export async function runFrontendProcess(requestPath, resultPath) {
     const request = JSON.parse(await readFile(requestPath, "utf8"));
+    // The process started before the build's options were known.
+    if (request.opts.shapeOverlay !== undefined)
+        process.env["SCRIPTC_SHAPE_OVERLAY"] = request.opts.shapeOverlay ? "1" : "0";
     clearCompileSessionCaches();
     setProvenanceSources(request.provenance);
+    shapeOverlayMemo = request.shapeOverlayMemo;
+    setShapeOverlayMemoDir(request.shapeOverlayMemo);
     // The compile that started this process prepared the cache root.
     configureLibDiagnostics((request.opts.outputKind ?? "exe") === "exe" && provenanceSources() === null
         ? await prepareBuildCacheRoot(buildCacheRoot())
@@ -800,6 +986,8 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
     const timing = compilationTiming();
     const timingStart = Date.now();
     entryPath = resolve(entryPath);
+    shapeOverlayMemo = null;
+    setShapeOverlayMemoDir(null);
     const outputKind = opts.outputKind ?? "exe";
     if ((opts.backend !== undefined && opts.backend !== "llvm") ||
         !["ir", "llvm", "asm", "obj", "exe"].includes(outputKind)) {
@@ -838,6 +1026,24 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             sourceTexts: new Map(),
         };
     }
+    if (opts.largePages === true && outputKind !== "exe") {
+        return {
+            ok: false,
+            diagnostics: [
+                nativeCodegenDiag("SC3002", "--large-pages is only supported for executable output", entryPath),
+            ],
+            sourceTexts: new Map(),
+        };
+    }
+    if (opts.cpuDispatch === true && outputKind !== "exe") {
+        return {
+            ok: false,
+            diagnostics: [
+                nativeCodegenDiag("SC3002", "--cpu-dispatch is only supported for executable output", entryPath),
+            ],
+            sourceTexts: new Map(),
+        };
+    }
     if (opts.nativeLinkInfo === true && outputKind !== "obj") {
         return {
             ok: false,
@@ -969,6 +1175,19 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             sourceTexts: new Map(),
         };
     }
+    const staticRefusal = staticLinkRefusal({
+        staticLink: opts.staticLink,
+        outputKind,
+        sanitize: opts.sanitize ?? false,
+        target: nativeCodegenTarget(),
+    });
+    if (staticRefusal !== null) {
+        return {
+            ok: false,
+            diagnostics: [nativeCodegenDiag("SC3002", staticRefusal, entryPath)],
+            sourceTexts: new Map(),
+        };
+    }
     try {
         windowsSubsystemLinkerArgs(buildPlatform, opts.windowsSubsystem);
     }
@@ -989,10 +1208,12 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
         platform: buildPlatform,
     });
     let profile;
+    let functionLayoutDigest;
     try {
         if (profileRefusal !== null)
             throw new Error(profileRefusal);
         profile = await readNativeProfile(opts);
+        functionLayoutDigest = await functionLayoutKey(opts);
     }
     catch (err) {
         return {
@@ -1003,7 +1224,8 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             sourceTexts: new Map(),
         };
     }
-    const cacheRoot = outputKind === "exe" && provenanceSources() === null
+    // A build that records block counts reuses no cached executable.
+    const cacheRoot = outputKind === "exe" && provenanceSources() === null && profile?.recordBlocks === undefined
         ? await prepareBuildCacheRoot(buildCacheRoot())
         : null;
     configureLibDiagnostics(cacheRoot);
@@ -1019,13 +1241,27 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             backend: "llvm",
             ...optimizationField(opts.optimization),
             ...(opts.strip ? { strip: true } : {}),
+            ...(opts.staticLink === true ? { staticLink: true } : {}),
             ...(opts.windowsSubsystem === "gui" ? { windowsSubsystem: "gui" } : {}),
             ...(opts.detachedExit === true ? { detachedExit: true } : {}),
+            // Calls into Node record the libnode pack; their entries record its
+            // identity (node-islands/libnode.ts) and a hit requires it unchanged.
+            libnodeIdentity: () => libnodeCacheKey(opts.libnode, process.env, dirname(entryPath)),
+            ...(opts.largePages === true ? { largePages: true } : {}),
+            ...(opts.hugeText === false ? { noHugeText: true } : {}),
+            ...(opts.exceptions === "rare" ? { exceptions: "rare" } : {}),
             ...targetCpuField(opts.targetCpu),
+            ...(opts.cpuDispatch === true ? { cpuDispatch: true } : {}),
             ...(profile === undefined ? {} : { profile: nativeProfileKey(profile) }),
+            ...(functionLayoutDigest === undefined ? {} : { functionLayout: functionLayoutDigest }),
             ...checkerField(),
             ...(youngNurseryRequested() ? { youngNursery: true } : {}),
+            ...(nodeIslandOptionsKey(opts.nodeIslands) !== ""
+                ? { nodeIslands: nodeIslandOptionsKey(opts.nodeIslands) }
+                : {}),
+            ...(heapCensusRequested() ? { heapCensus: true } : {}),
             npmStatic: opts.npmStatic ?? null,
+            ...(shapeOverlayEnabled() ? { shapeOverlay: true } : {}),
             ffiProfile: opts.ffiProfilePath === undefined || ffiProfileBytes === null
                 ? null
                 : { path: opts.ffiProfilePath, bytes: ffiProfileBytes },
@@ -1061,10 +1297,19 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             implementation: implementation.digest,
             implementationDependencies: implementation.dependencies,
         };
+        shapeOverlayMemo = shapeOverlayMemoDir(cacheRoot, implementation.digest);
+        setShapeOverlayMemoDir(shapeOverlayMemo);
     }
-    const earlyHit = earlyCacheOptions === null
+    // A cache hit emits no module, so it would write no representation report.
+    const cachedHit = earlyCacheOptions === null || representationReportPath() !== null
         ? null
         : await readEarlyExecutableCache(cacheRoot, earlyCacheOptions);
+    // A --libnode=beside build that calls into Node places its island modules
+    // next to the executable from the lowered module, which a cache hit does
+    // not have: such builds take the full path.
+    const earlyHit = cachedHit !== null && cachedHit.native.nodeIsland === true && opts.libnode === "beside"
+        ? null
+        : cachedHit;
     if (earlyHit !== null) {
         timing("executable-cache-hit");
         if (earlyCacheOptions === null) {
@@ -1074,7 +1319,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
         // names is just as untyped as when it was built.
         if (warningSink !== undefined && earlyHit.performance !== undefined) {
             warningSink.warnings = earlyHit.performance;
-            warningSink.sourceTexts = new Map();
+            warningSink.sourceTexts = cachedWarningSources(earlyHit.performance);
         }
         const executableCacheOptions = earlyCacheOptions;
         // Route/proof metadata is independently evictable. A full-compiler
@@ -1091,6 +1336,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     path: opts.outPath,
                     translationUnitPath: earlyHit.llvmPath,
                     backend: earlyHit.native.backend,
+                    ...(earlyHit.profileMatch === undefined ? {} : { profileMatch: earlyHit.profileMatch }),
                 },
                 binaryPath: opts.outPath,
                 llvmPath: earlyHit.llvmPath,
@@ -1142,7 +1388,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                 nativeSources = staged.sources;
                 nativeInputPath = nativeSources.llvmSourcePath;
             }
-            await compileExecutableNative(earlyHit.native, nativeInputPath, opts.outPath, opts.sanitize ?? false, ffi, opts.windowsSubsystem, opts.strip, null, nativeProgramObject?.dependencies, opts.nativeProgramObject === true
+            await compileExecutableNative(earlyHit.native, nativeInputPath, opts.outPath, opts.sanitize ?? false, ffi, opts.windowsSubsystem, opts.strip, opts.staticLink === true, null, nativeProgramObject?.dependencies, opts.nativeProgramObject === true
                 ? undefined
                 : async ({ dependencies }) => {
                     await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
@@ -1154,8 +1400,9 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                         executableRestored: true,
                         nativeDependencies: dependencies,
                         frontend: earlyHit.frontend,
+                        ...profileMatchField(nativeProgramObject),
                     });
-                }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, hitSources.llvmPath);
+                }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, hitSources.llvmPath, nativeProfileLayout(profile), opts.hugeText !== false);
             if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
                 await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath);
             }
@@ -1177,6 +1424,13 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     sourceTexts: new Map(),
                 };
             }
+            if (err instanceof NativeCodegenError) {
+                return {
+                    ok: false,
+                    diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)],
+                    sourceTexts: new Map(),
+                };
+            }
             throw err;
         }
         finally {
@@ -1196,6 +1450,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                 path: opts.outPath,
                 translationUnitPath: earlyHit.llvmPath,
                 backend: earlyHit.native.backend,
+                ...profileMatchField(nativeProgramObject),
             },
             binaryPath: opts.outPath,
             llvmPath: earlyHit.llvmPath,
@@ -1254,7 +1509,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             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
+        await compileExecutableNative(nativeFeatures, nativeProgramObject?.linkPath ?? llvmSourcePath, opts.outPath, opts.sanitize ?? false, ffi, opts.windowsSubsystem, opts.strip, opts.staticLink === true, programSplit, nativeProgramObject?.dependencies, opts.nativeProgramObject === true
             ? undefined
             : async ({ dependencies }) => {
                 await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
@@ -1265,9 +1520,10 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     frontend: frontendInputs.snapshot(),
                     ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
                     ...performanceWarnings(warningSink),
+                    ...profileMatchField(nativeProgramObject),
                 });
                 publishedExecutable = true;
-            }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, llvmPath);
+            }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, llvmPath, nativeProfileLayout(profile), opts.hugeText !== false);
         timing("native-link");
         if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
             await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath);
@@ -1280,6 +1536,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                 frontend: frontendInputs.snapshot(),
                 ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
                 ...performanceWarnings(warningSink),
+                ...profileMatchField(nativeProgramObject),
             }).catch(() => undefined);
         }
     }
@@ -1296,6 +1553,13 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                 sourceTexts,
             };
         }
+        if (err instanceof NativeCodegenError) {
+            return {
+                ok: false,
+                diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)],
+                sourceTexts,
+            };
+        }
         throw err;
     }
     finally {
@@ -1309,7 +1573,6 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
     }
     await pruneBuildCache(cacheRoot);
     timing("complete");
-    const profileMatch = nativeProgramObject?.profileMatch;
     return {
         ok: true,
         artifact: {
@@ -1317,7 +1580,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             path: opts.outPath,
             translationUnitPath: llvmPath,
             backend,
-            ...(profileMatch === undefined ? {} : { profileMatch }),
+            ...profileMatchField(nativeProgramObject),
         },
         binaryPath: opts.outPath,
         llvmPath,
@@ -1685,6 +1948,8 @@ async function compileLibraryTracked(opts, frontendInputs) {
             pointerBits: buildPlatform === "wasi" ? 32 : 64,
             wasi: buildPlatform === "wasi",
             objectAudit: opts.sanitize === true,
+            sanitizeAttributes: opts.sanitize === true,
+            timing,
             ...inlineRcOption(profile.optimization, opts.sanitize === true),
         });
         timing("llvm-emit", {