@scriptc/compiler 0.0.34 → 0.0.36

package/dist/index.js

@@ -1,44 +1,58 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { InternalCompilerError } from "./errors.js";
+import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
-import { buildCacheRoot, CcCompileError, compileC, compileLibArchive, mobileLibraryTarget, mobileTargetRefusal, prepareBuildCacheRoot, pruneBuildCache, resolveCc, targetPlatform } from "./backend/cc.js";
-import { emitModule } from "./backend/emission/emitter.js";
+import { buildCacheRoot, CcCompileError, clearCcCaches, compileC, compileLibArchive, compilerDriverSupportsPersistentCache, configuredTargetPlatform, executableNativeEnvironmentFingerprint, mobileLibraryTarget, mobileTargetRefusal, prepareBuildCacheRoot, pruneBuildCache, resolveCc, targetPlatform, toolchainEnvironmentCachePolicy, toolchainEnvironmentFingerprint } from "./backend/native-toolchain.js";
+import { emitCModule } from "./backend/c/c-emitter.js";
 import { emitLlvmModule, LlvmUnsupportedError } from "./backend/llvm/emitter.js";
-import { rebaseLibrarySourceComments, replaceLibraryIdentity, stripLibraryIdentity, stripLibrarySourceComments } from "./backend/library-identity.js";
-import { checkerPanicDiag, ffiNativeBuildDiag, libAsyncExportDiag, libAsyncSurfaceDiag, libExportUnresolvedDiag, libGenericExportDiag, libIntBoundaryDiag, libNpmIneligibleDiag, libSidecarDiag, libUnmappableSignatureDiag, iceDiag, isCheckerPanic, LIB_INBOUND_BYTES_TRAP_CODE, LIB_RUNTIME_TRAP_CODES } from "./diagnostics/diagnostic.js";
+import { emitNativeArtifact, NativeCodegenError } from "./backend/native-codegen.js";
+import { privateSiblingPath } from "./backend/build-cache.js";
+import { nativeCodegenTarget, nativeCodegenTargetRefusal } from "./backend/targets.js";
+import { createNativeLinkInfo } from "./backend/native-link-info.js";
+import { createRuntimeLinkPlan, linkRuntimePackExecutable, RuntimePackError } from "./backend/runtime-pack.js";
+import { splitLlvmLibraryProgram, splitLlvmProgram } from "./backend/llvm/split.js";
+import { rebaseLibrarySourceComments, replaceLibraryIdentity, stripLibraryIdentity, stripLibrarySourceComments } from "./backend/library-identity-markers.js";
+import { checkerPanicDiag, ffiNativeBuildDiag, libAsyncExportDiag, libAsyncSurfaceDiag, libExportUnresolvedDiag, libGenericExportDiag, libIntBoundaryDiag, libNpmIneligibleDiag, libSidecarDiag, libUnmappableSignatureDiag, iceDiag, isCheckerPanic, LIB_INBOUND_BYTES_TRAP_CODE, LIB_RUNTIME_TRAP_CODES, nativeCodegenDiag } from "./diagnostics/diagnostic.js";
 import { checkLibraryIntegerSlots, classSeed, hasIntSlots, numberCarrierKind } from "./library/int-infer.js";
-import { loadLibraryProfile, profileRemediation, profileTeaching } from "./library/profile.js";
-import { decorateLibraryRefusals, evaluateLibraryFences } from "./library/fence-eval.js";
+import { loadLibraryProfile, profileRemediation, profileTeaching } from "./library/library-profile.js";
+import { clearFenceEvalCaches, decorateLibraryRefusals, evaluateLibraryFences } from "./library/fence-eval.js";
 import { assembleTrapTeaching } from "./library/trap-teaching.js";
-import { buildSidecar, canonicalModuleGraph, canonicalPath, compilerReleaseVersion, libraryIdentityHashes, updateSidecarIdentity, } from "./library/sidecar.js";
+import { buildSidecar, canonicalModuleGraph, canonicalPath, clearSidecarCaches, compilerReleaseVersion, libraryIdentityHashes, updateSidecarIdentity, } from "./library/sidecar.js";
 import { validateSidecar } from "./library/sidecar-validate.js";
 import { entryFunctionExports } from "./frontend/lib-exports.js";
 import { entryContractFacts } from "./frontend/lib-contract.js";
-import { moduleLibAsyncSurface, moduleLibNondeterministicSurface, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, moduleUsesAssert, moduleUsesCopying, moduleUsesDc, moduleUsesDgram, moduleUsesDynAsync, moduleUsesDynInvoke, moduleUsesEmitter, moduleUsesFetch, moduleUsesFileHandle, moduleUsesFsWatch, moduleUsesHttp2, moduleUsesHttpServer, moduleUsesInspect, moduleUsesLegacyTextDecoder, moduleUsesNet, moduleUsesNodeTest, moduleUsesParseArgs, moduleUsesProcessEvents, moduleUsesQs, moduleUsesRegex, moduleUsesSearchParams, moduleUsesStream, moduleUsesSymbol, moduleUsesTls, moduleUsesTlsCa, moduleUsesZlib } from "./ir/nodes.js";
+import { moduleLibAsyncSurface, moduleLibNondeterministicSurface, moduleEmbedsBuiltin, moduleEmbedsCompressedNpm, moduleUsesAssert, moduleUsesCopying, moduleUsesDc, moduleUsesDgram, moduleUsesDynAsync, moduleUsesDynInvoke, moduleUsesEmitter, moduleUsesFetch, moduleUsesFileHandle, moduleUsesFsWatch, moduleUsesHttp2, moduleUsesHttpServer, moduleUsesInspect, moduleUsesLegacyTextDecoder, moduleUsesNet, moduleUsesNodeTest, moduleUsesParseArgs, moduleUsesProcessEvents, moduleUsesQs, moduleUsesRegex, moduleUsesSearchParams, moduleUsesStream, moduleUsesSymbol, moduleUsesTls, moduleUsesTlsCa, moduleUsesZlib } from "./ir/ir.js";
 import { serializeModule } from "./ir/serialize.js";
 import { validateModule } from "./ir/validate.js";
 import { canonicalBuiltinModule, checkPreflight, isNodeTypesPath, loadProgram, locOf, requiresOf, resolveNpmImport } from "./frontend/program.js";
 import { npmStaticIneligibleReason, npmStaticOffenders, npmStaticPackageOfPath } from "./frontend/npm-static.js";
 import { provenanceSources } from "./frontend/provenance-registry.js";
 import { clearResolveCaches, resolveBareModule } from "./frontend/resolve.js";
-import { isJsSourceFileName, isRelativeSpecifier } from "./frontend/shared.js";
+import { isJsSourceFileName } from "./frontend/tsc-codes.js";
+import { isRelativeSpecifier, packageNameOfSpecifier } from "./frontend/workspace-registry.js";
 import { lowerToIr } from "./frontend/lowering/lowerer.js";
-import { loadFfiProfile } from "./ffi/profile.js";
+import { loadFfiProfile } from "./ffi/ffi-manifest.js";
 import { hasForeignFfiCallback } from "./backend/ffi-callbacks.js";
 import { FrontendInputTracker, trackedReadFile } from "./frontend/input-tracker.js";
-import { libraryFrontendImplementationFingerprint, publishEarlyLibraryCache, readEarlyLibraryCache, readSemanticLibraryCache } from "./library/early-cache.js";
+import { libraryFrontendImplementationFingerprint, publishEarlyLibraryCache, readEarlyLibraryCache, readSemanticLibraryCache } from "./library/library-cache.js";
 import { createSourceLineRebaser } from "./library/semantic-source.js";
+import { publishEarlyExecutableCache, publishEarlyExecutableRoute, readEarlyExecutableCache } from "./executable/executable-cache.js";
+import { compilerImplementationIdentity } from "./library/compiler-self-identity.js";
 export const VERSION = "0.0.1";
-export { compileC, runtimeSrcDir } from "./backend/cc.js";
-export { ANDROID_MIN_API, IPHONEOS_MIN_VERSION, isAndroidTarget, isIosTarget, isMobileTarget, mobileLibraryTarget, mobileTargetRefusal } from "./backend/cc.js";
-export { emitModule } from "./backend/emission/emitter.js";
-export { renderAll, renderDiagnostic } from "./diagnostics/render.js";
+export { EXTERNAL_OBJECT_ABI_STABILITY, RUNTIME_ABI_MARKER, RUNTIME_ABI_VERSION, } from "./backend/runtime-abi.js";
+export { InternalCompilerError } from "./errors.js";
+export { compileC, runtimeSrcDir, warmNativeCaches, } from "./backend/native-toolchain.js";
+export { ANDROID_MIN_API, IPHONEOS_MIN_VERSION, isAndroidTarget, isIosTarget, isMobileTarget, mobileLibraryTarget, mobileTargetRefusal } from "./backend/native-toolchain.js";
+export { emitCModule, emitCModule as emitModule, } from "./backend/c/c-emitter.js";
+export { renderDiagnostics, renderDiagnostics as renderAll, renderDiagnostic, } from "./diagnostics/render.js";
 export { renderCoverage } from "./coverage/report.js";
 export { generateSurfaceManifest, renderSurfaceManifest, MANIFEST_SCHEMA_VERSION, } from "./coverage/surface-manifest.js";
 export { NODE24_FETCH_COMPAT_PROFILE, } from "./compat/fetch-profile.js";
 export { LIB_FN_SIGS, validateModule } from "./ir/validate.js";
+export { deserializeModule, IR_VERSION, serializeModule } from "./ir/serialize.js";
 export { resolveLibraryFences } from "./library/fence-eval.js";
-export { loadLibraryProfile, profileTeaching, profileRemediation, LIB_PARAM_CLASSES, LIB_RETURN_CLASSES, } from "./library/profile.js";
-export { loadFfiProfile, FFI_CALLBACK_PARAM_CLASSES, FFI_PARAM_CLASSES, FFI_RETURN_CLASSES, } from "./ffi/profile.js";
+export { loadLibraryProfile, profileTeaching, profileRemediation, LIB_PARAM_CLASSES, LIB_RETURN_CLASSES, } from "./library/library-profile.js";
+export { loadFfiProfile, FFI_CALLBACK_PARAM_CLASSES, FFI_PARAM_CLASSES, FFI_RETURN_CLASSES, } from "./ffi/ffi-manifest.js";
 export { assembleTrapTeaching, TRAP_TEACHING_MARKER, TRAP_TEACHING_SEP, } from "./library/trap-teaching.js";
 export { abiExportSuffixes, buildSidecar, canonicalModuleGraph, canonicalPath, compilerReleaseVersion, libraryIdentityHashes, SIDECAR_FORMAT, } from "./library/sidecar.js";
 export { validateSidecar } from "./library/sidecar-validate.js";
@@ -48,7 +62,7 @@ export { ambientDtsPath, isExactExternalTypeSpecifier, overridesDtsPath } from "
 export { resolveProvenanceSources } from "./frontend/provenance.js";
 export { wasiGuestPath } from "./wasi-paths.js";
 export { setProvenanceSources, } from "./frontend/provenance-registry.js";
-export * as ir from "./ir/nodes.js";
+export * as ir from "./ir/ir.js";
 /** The LLVM backend's tier refusal as a diagnostic. SC3xxx = backend
  * coverage (the program is fine — this backend doesn't compile it yet);
  * the parenthesized kind tag is machine-readable for the differential
@@ -197,6 +211,12 @@ export function buildTargetPlatform(env = process.env) {
         return process.platform;
     }
 }
+/** Target-platform classification without compiler or SDK discovery. Source
+ * artifacts need target semantics for lowering, but do not need a native
+ * toolchain merely to decide whether that target is Windows, WASI, etc. */
+export function sourceTargetPlatform(env = process.env) {
+    return configuredTargetPlatform(env);
+}
 /** --npm-static=auto (and library mode's mandatory twin): one throwaway
  * load finds every bare npm import the program's own modules make, then
  * the eligibility heuristics (npm-static.ts) pick the packages whose
@@ -294,8 +314,7 @@ function packagesNamedByDiag(message, optedIn) {
     const hits = new Set();
     for (const m of message.matchAll(/Module '"([^"]+)"'/g)) {
         const spec = m[1];
-        const parts = spec.split("/");
-        const prefix = spec.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+        const prefix = packageNameOfSpecifier(spec);
         if (optedIn.has(prefix))
             hits.add(prefix);
     }
@@ -306,13 +325,6 @@ function packagesNamedByDiag(message, optedIn) {
     }
     return hits;
 }
-/** The package-wide --npm-static name containing an exact bare specifier.
- * External mappings are exact (subpaths included), while npm-static owns a
- * whole package, so any mapped subpath conflicts with that package opt-in. */
-function packageNameOfBareSpecifier(specifier) {
-    const parts = specifier.split("/");
-    return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
-}
 /** The one frontend, three npm postures: `undefined`/explicit package
  * lists and `"auto"` are the executable lane's (--npm-static; fallback =
  * island). `"lib"` is library mode's mandatory auto twin — the same
@@ -367,7 +379,7 @@ function runFrontend(entryPath, npmStatic, externalTypes) {
     if (requested.length > 0 && externalTypes !== undefined) {
         const externalSpecifiersByPackage = new Map();
         for (const specifier of Object.keys(externalTypes)) {
-            const pkg = packageNameOfBareSpecifier(specifier);
+            const pkg = packageNameOfSpecifier(specifier);
             const specs = externalSpecifiersByPackage.get(pkg) ?? [];
             specs.push(specifier);
             externalSpecifiersByPackage.set(pkg, specs);
@@ -628,21 +640,279 @@ export function analyze(entryPath, opts = {}) {
     }
 }
 /** The whole pipeline: load → preflight → lower → validate → emit C → clang. */
+function clearCompileSessionCaches() {
+    clearResolveCaches();
+    clearCcCaches();
+    clearSidecarCaches();
+    clearFenceEvalCaches();
+}
 export async function compile(entryPath, opts) {
+    clearCompileSessionCaches();
+    const frontendInputs = new FrontendInputTracker();
+    return frontendInputs.run(() => compileTracked(entryPath, opts, frontendInputs));
+}
+/** Build-time API compatibility fence: a caller's existing CompileOptions
+ * variable must retain the executable result aliases without narrowing. */
+async function assertCompileOptionsCompatibility(entryPath, opts) {
+    const result = await compile(entryPath, opts);
+    if (result.ok) {
+        const binaryPath = result.binaryPath;
+        void binaryPath;
+    }
+}
+void assertCompileOptionsCompatibility;
+/** The historical exported CompileResult itself remains executable-shaped. */
+function assertCompileResultCompatibility(result) {
+    if (result.ok) {
+        const binaryPath = result.binaryPath;
+        void binaryPath;
+    }
+}
+void assertCompileResultCompatibility;
+function executableNativeFeatures(mod, backend, dynamic, optimization, llvmRefusal) {
+    return {
+        backend,
+        ...(optimization === "dev" ? { optimization: "dev" } : {}),
+        ...(llvmRefusal === undefined ? {} : { llvmRefusal }),
+        dynamic,
+        regex: moduleUsesRegex(mod),
+        copying: moduleUsesCopying(mod),
+        textDecoderLegacy: moduleUsesLegacyTextDecoder(mod),
+        fileHandle: moduleUsesFileHandle(mod),
+        fetch: moduleUsesFetch(mod),
+        netIsland: moduleEmbedsBuiltin(mod, "node:http") ||
+            moduleEmbedsBuiltin(mod, "node:https") ||
+            moduleEmbedsBuiltin(mod, "node:net") ||
+            moduleEmbedsBuiltin(mod, "node:tls"),
+        zlib: moduleUsesZlib(mod) || moduleEmbedsCompressedNpm(mod),
+        assert: moduleUsesAssert(mod),
+        inspect: moduleUsesInspect(mod),
+        dynInvoke: moduleUsesDynInvoke(mod),
+        dc: moduleUsesDc(mod),
+        dynAsync: moduleUsesDynAsync(mod),
+        events: moduleUsesProcessEvents(mod),
+        emitter: moduleUsesEmitter(mod),
+        symbol: moduleUsesSymbol(mod),
+        searchParams: moduleUsesSearchParams(mod),
+        qs: moduleUsesQs(mod),
+        parseArgs: moduleUsesParseArgs(mod),
+        stream: moduleUsesStream(mod),
+        net: moduleUsesNet(mod),
+        http: moduleUsesHttpServer(mod),
+        http2: moduleUsesHttp2(mod),
+        dgram: moduleUsesDgram(mod),
+        watch: moduleUsesFsWatch(mod),
+        foreignFfi: hasForeignFfiCallback(mod.ffiImports ?? []),
+        nodeTest: moduleUsesNodeTest(mod),
+        tls: moduleUsesTls(mod),
+        tlsCa: moduleUsesTlsCa(mod),
+    };
+}
+async function compileExecutableNative(features, cPath, outPath, sanitize, ffi, programSplit = null, programObjectDependencies = [], onArtifactReady) {
+    const programIsObject = /\.(?:o|obj)$/.test(cPath);
+    const runtimePackTarget = programIsObject && !sanitize && process.env["SCRIPTC_RUNTIME_PACK"] !== "0"
+        ? nativeCodegenTarget()
+        : null;
+    if (runtimePackTarget !== null) {
+        const plan = await createRuntimeLinkPlan({
+            target: runtimePackTarget,
+            programObject: cPath,
+            outPath,
+            features,
+            ffi,
+            optimization: features.optimization ?? "release",
+            programObjectDependencies,
+        });
+        const cacheableLinker = onArtifactReady !== undefined && process.env["SCRIPTC_LINKER"] === undefined && ffi === null &&
+            toolchainEnvironmentCachePolicy().completeArtifacts &&
+            await compilerDriverSupportsPersistentCache(resolveCc(), toolchainEnvironmentFingerprint());
+        await linkRuntimePackExecutable(plan, {
+            // A caller-selected linker can be a mutable wrapper with hidden inputs,
+            // and a PATH-selected `clang` can be one too. FFI profiles and mutable
+            // linker search environments likewise name transitive files that the
+            // top-level dependency snapshot cannot prove. Only a direct driver in a
+            // stable link environment may publish a reusable final executable.
+            ...(cacheableLinker ? { onArtifactReady } : {}),
+        });
+        return;
+    }
+    const effectiveProgramSplit = programSplit ??
+        (!programIsObject && features.optimization === "dev" && features.backend === "llvm" && !sanitize
+            ? splitLlvmProgram(await readFile(cPath, "utf8"))
+            : null);
+    const objectLinkDir = programIsObject
+        ? await mkdtemp(join(tmpdir(), "scriptc-object-link-"))
+        : null;
+    const linkDriverSource = objectLinkDir === null
+        ? cPath
+        : join(objectLinkDir, "driver.c");
+    if (objectLinkDir !== null)
+        await writeFile(linkDriverSource, "/* scriptc object link driver */\n");
+    try {
+        await compileC({
+            cPath: linkDriverSource,
+            outPath,
+            cacheIdentity: "scriptc-generated-v1",
+            ...(features.optimization === "dev" ? { optimization: "dev" } : {}),
+            ...(effectiveProgramSplit === null
+                ? {}
+                : {
+                    programShards: effectiveProgramSplit.shards,
+                    programPublicSymbols: effectiveProgramSplit.publicSymbols,
+                }),
+            sanitize,
+            dynamic: features.dynamic,
+            regex: features.regex,
+            copying: features.copying,
+            textDecoderLegacy: features.textDecoderLegacy,
+            fileHandle: features.fileHandle,
+            fetch: features.fetch,
+            netIsland: features.netIsland,
+            zlib: features.zlib,
+            assert: features.assert,
+            inspect: features.inspect,
+            dynInvoke: features.dynInvoke,
+            dc: features.dc,
+            dynAsync: features.dynAsync,
+            events: features.events,
+            emitter: features.emitter,
+            symbol: features.symbol,
+            searchParams: features.searchParams,
+            qs: features.qs,
+            parseArgs: features.parseArgs,
+            stream: features.stream,
+            net: features.net,
+            http: features.http,
+            http2: features.http2,
+            dgram: features.dgram,
+            watch: features.watch,
+            foreignFfi: features.foreignFfi,
+            nodeTest: features.nodeTest,
+            tls: features.tls,
+            tlsCa: features.tlsCa,
+            ...(onArtifactReady === undefined ? {} : { onArtifactReady }),
+            ...(ffi === null && !programIsObject
+                ? {}
+                : {
+                    linkInputs: [
+                        ...(programIsObject ? [cPath] : []),
+                        ...(ffi?.libraries ?? []),
+                    ],
+                    ...(ffi === null ? {} : { systemLibraries: ffi.systemLibraries }),
+                }),
+        });
+    }
+    finally {
+        if (objectLinkDir !== null) {
+            await rm(objectLinkDir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+}
+async function emitNativeProgramObject(entryPath, opts, llvm) {
+    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
+    // private name isolates concurrent builds; retain .o so the driver links
+    // it rather than attempting to compile it as source.
+    const linkPath = `${privateSiblingPath(artifactPath, "native-program-object")}.o`;
+    try {
+        const artifact = await emitNativeArtifact({
+            outputPath: linkPath,
+            llvm,
+            outputKind: "obj",
+            sourcePath: entryPath,
+            optimization: opts.optimization === "dev" ? "0" : "2",
+            ...(opts.sanitize === undefined ? {} : { sanitize: opts.sanitize }),
+        });
+        return { linkPath, artifactPath, dependencies: artifact.dependencies };
+    }
+    catch (error) {
+        await rm(linkPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function usesPrecompiledRuntimePack(opts, backend) {
+    if (backend !== "llvm" || opts.sanitize === true ||
+        process.env["SCRIPTC_RUNTIME_PACK"] === "0" ||
+        process.env["SCRIPTC_FETCH_CURL"] === "1")
+        return false;
+    const cc = process.env["SCRIPTC_CC"] ?? "";
+    return (cc === "" || cc === "clang") && nativeCodegenTarget() !== null;
+}
+function runtimePackDiagnostic(error, entryPath) {
+    return nativeCodegenDiag(error.code === "unsupported" ? "SC3002" : "SC3003", error.message, entryPath);
+}
+async function compileTracked(entryPath, opts, frontendInputs) {
+    entryPath = resolve(entryPath);
+    const outputKind = opts.outputKind ?? "exe";
+    if (opts.nativeLinkInfo === true && outputKind !== "obj") {
+        return {
+            ok: false,
+            diagnostics: [nativeCodegenDiag("SC3002", "native link info is available only for object output", entryPath)],
+            sourceTexts: new Map(),
+        };
+    }
+    if (opts.nativeProgramObject === true &&
+        (outputKind !== "exe" || opts.backend !== "llvm")) {
+        return {
+            ok: false,
+            diagnostics: [nativeCodegenDiag("SC3002", "native program-object validation requires an executable build with backend explicitly set to llvm", entryPath)],
+            sourceTexts: new Map(),
+        };
+    }
     let ffi = null;
+    let ffiProfileBytes = null;
     if (opts.ffiProfilePath !== undefined) {
-        const loaded = loadFfiProfile(opts.ffiProfilePath);
+        const ffiProfilePath = resolve(opts.ffiProfilePath);
+        const loaded = loadFfiProfile(ffiProfilePath);
         if (!loaded.ok) {
             return { ok: false, diagnostics: loaded.diagnostics, sourceTexts: new Map() };
         }
         ffi = loaded.profile;
+        ffiProfileBytes = loaded.profileBytes;
+    }
+    let buildPlatform;
+    if (outputKind === "exe") {
+        buildPlatform = buildTargetPlatform();
+    }
+    else {
+        try {
+            buildPlatform = sourceTargetPlatform();
+        }
+        catch (err) {
+            return {
+                ok: false,
+                diagnostics: [{
+                        code: "SC3002",
+                        message: err instanceof Error ? err.message : String(err),
+                        loc: { file: entryPath, start: 0, end: 0 },
+                    }],
+                sourceTexts: new Map(),
+            };
+        }
+        if (outputKind === "asm" || outputKind === "obj") {
+            const refusal = nativeCodegenTargetRefusal();
+            if (refusal !== null) {
+                return {
+                    ok: false,
+                    diagnostics: [nativeCodegenDiag("SC3002", refusal, entryPath)],
+                    sourceTexts: new Map(),
+                };
+            }
+            if (opts.sanitize === true) {
+                return {
+                    ok: false,
+                    diagnostics: [nativeCodegenDiag("SC3002", `--sanitize is not supported with --emit=${outputKind}; AddressSanitizer instrumentation parity is not available in the LLVM native helper yet`, entryPath)],
+                    sourceTexts: new Map(),
+                };
+            }
+        }
     }
-    const buildPlatform = buildTargetPlatform();
     // Mobile triples are library-mode targets: the archive an embedding app
     // links is the artifact, and only the library-admissible runtime surface
     // is verified on those device classes. The executable lane refuses before
     // any frontend work — a pure env check, so the refusal needs no toolchain.
-    {
+    if (outputKind === "exe") {
         const entryLoc = { file: entryPath, start: 0, end: 0 };
         const mobileTarget = mobileLibraryTarget();
         if (mobileTarget !== null) {
@@ -664,6 +934,151 @@ export async function compile(entryPath, opts) {
             };
         }
     }
+    const cacheRoot = outputKind === "exe" && provenanceSources() === null
+        ? await prepareBuildCacheRoot(buildCacheRoot())
+        : null;
+    let earlyCacheOptions = null;
+    if (outputKind === "exe") {
+        const implementation = await compilerImplementationIdentity();
+        earlyCacheOptions = {
+            entryPath,
+            outDir: opts.outDir,
+            outPath: opts.outPath,
+            emitIr: opts.emitIr ?? false,
+            sanitize: opts.sanitize ?? false,
+            dynamic: opts.dynamic ?? false,
+            backend: opts.backend ?? "auto",
+            ...(opts.optimization === "dev" ? { optimization: "dev" } : {}),
+            npmStatic: opts.npmStatic ?? null,
+            ffiProfile: opts.ffiProfilePath === undefined || ffiProfileBytes === null
+                ? null
+                : { path: opts.ffiProfilePath, bytes: ffiProfileBytes },
+            target: `${process.env["SCRIPTC_TARGET"] ?? "native"}:${buildPlatform}:${process.arch}:${opts.nativeProgramObject === true
+                ? "helper-object"
+                : (opts.backend !== "c" && opts.sanitize !== true &&
+                    process.env["SCRIPTC_RUNTIME_PACK"] !== "0" &&
+                    process.env["SCRIPTC_FETCH_CURL"] !== "1" &&
+                    ((process.env["SCRIPTC_CC"] ?? "") === "" || process.env["SCRIPTC_CC"] === "clang") &&
+                    nativeCodegenTarget() !== null) ? "runtime-pack" : "driver-tu"}`,
+            compiler: [process.env["SCRIPTC_LINKER"] ?? process.env["SCRIPTC_CC"] ?? "clang"],
+            nativeEnvironment: await executableNativeEnvironmentFingerprint(),
+            nodeVersion: process.version,
+            implementation: implementation.digest,
+            implementationDependencies: implementation.dependencies,
+        };
+    }
+    const earlyHit = earlyCacheOptions === null
+        ? null
+        : await readEarlyExecutableCache(cacheRoot, earlyCacheOptions);
+    if (earlyHit !== null) {
+        if (earlyCacheOptions === null) {
+            throw new InternalCompilerError("executable cache hit without executable cache options");
+        }
+        const executableCacheOptions = earlyCacheOptions;
+        if (!opts.emitIr) {
+            const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
+            await rm(join(opts.outDir, `${stem}.ir.json`), { force: true });
+        }
+        // Route/proof metadata is independently evictable. A full-compiler
+        // fallback that still finds the validated payload repairs that lightweight
+        // index so the next identical CLI invocation can avoid this module graph.
+        await publishEarlyExecutableRoute(cacheRoot, executableCacheOptions).catch(() => undefined);
+        if (earlyHit.executableRestored) {
+            await pruneBuildCache(cacheRoot);
+            return {
+                ok: true,
+                artifact: {
+                    kind: "exe",
+                    path: opts.outPath,
+                    translationUnitPath: earlyHit.cPath,
+                    backend: earlyHit.native.backend,
+                    ...(earlyHit.native.llvmRefusal === undefined
+                        ? {}
+                        : { llvmRefusal: earlyHit.native.llvmRefusal }),
+                },
+                binaryPath: opts.outPath,
+                cPath: earlyHit.cPath,
+                backend: earlyHit.native.backend,
+                ...(earlyHit.irPath === undefined ? {} : { irPath: earlyHit.irPath }),
+                ...(earlyHit.native.llvmRefusal === undefined
+                    ? {}
+                    : { llvmRefusal: earlyHit.native.llvmRefusal }),
+            };
+        }
+        let nativeInputPath = earlyHit.cPath;
+        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 {
+                nativeProgramObject = await emitNativeProgramObject(entryPath, opts, await readFile(earlyHit.cPath, "utf8"));
+                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 {
+            await compileExecutableNative(earlyHit.native, nativeInputPath, opts.outPath, opts.sanitize ?? false, ffi, null, nativeProgramObject?.dependencies, opts.nativeProgramObject === true ? undefined : async ({ dependencies }) => {
+                await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
+                    ...earlyHit,
+                    executableRestored: true,
+                    nativeDependencies: dependencies,
+                    frontend: earlyHit.frontend,
+                });
+            });
+            if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
+                await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath);
+            }
+        }
+        catch (err) {
+            if (err instanceof RuntimePackError) {
+                return { ok: false, diagnostics: [runtimePackDiagnostic(err, entryPath)], sourceTexts: new Map() };
+            }
+            if (ffi !== null && err instanceof CcCompileError) {
+                return {
+                    ok: false,
+                    diagnostics: [ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath)],
+                    sourceTexts: new Map(),
+                };
+            }
+            throw err;
+        }
+        finally {
+            if (nativeProgramObject !== null) {
+                await rm(nativeProgramObject.linkPath, { force: true }).catch(() => undefined);
+            }
+        }
+        await pruneBuildCache(cacheRoot);
+        return {
+            ok: true,
+            artifact: {
+                kind: "exe",
+                path: opts.outPath,
+                translationUnitPath: earlyHit.cPath,
+                backend: earlyHit.native.backend,
+                ...(earlyHit.native.llvmRefusal === undefined
+                    ? {}
+                    : { llvmRefusal: earlyHit.native.llvmRefusal }),
+            },
+            binaryPath: opts.outPath,
+            cPath: earlyHit.cPath,
+            backend: earlyHit.native.backend,
+            ...(earlyHit.irPath === undefined ? {} : { irPath: earlyHit.irPath }),
+            ...(earlyHit.native.llvmRefusal === undefined
+                ? {}
+                : { llvmRefusal: earlyHit.native.llvmRefusal }),
+        };
+    }
     const fe = runFrontend(entryPath, opts.npmStatic);
     let lowered;
     let entryText;
@@ -713,7 +1128,7 @@ export async function compile(entryPath, opts) {
             if (unavailable !== null) {
                 return fail([targetRefusalDiag("wasm32-wasi", unavailable.surface, unavailable.loc)]);
             }
-            if (opts.backend === "c") {
+            if (opts.backend === "c" || outputKind === "c") {
                 const asyncSurface = moduleLibAsyncSurface(lowered.module);
                 if (asyncSurface !== null) {
                     return fail([
@@ -728,24 +1143,128 @@ export async function compile(entryPath, opts) {
     finally {
         fe.dispose();
     }
+    const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
+    const defaultSourcePaths = {
+        ir: join(opts.outDir, `${stem}.ir.json`),
+        c: join(opts.outDir, `${stem}.c`),
+        llvm: join(opts.outDir, `${stem}.ll`),
+        asm: join(opts.outDir, `${stem}.s`),
+        obj: join(opts.outDir, `${stem}.o`),
+    };
+    const defaultExecutablePaths = [
+        join(opts.outDir, stem),
+        join(opts.outDir, `${stem}.exe`),
+        join(opts.outDir, `${stem}.wasm`),
+    ];
+    const removeStaleSourceArtifacts = async (keep) => {
+        const kept = new Set(keep.map((path) => resolve(path)));
+        const candidates = outputKind === "exe"
+            // Executable builds can generate only these compatibility/translation
+            // unit siblings. Assembly and object outputs are independent primary
+            // artifacts, so an executable build must never claim or delete them.
+            ? [defaultSourcePaths.ir, defaultSourcePaths.c, defaultSourcePaths.llvm]
+            : opts.defaultOutputPath === true
+                ? [...Object.values(defaultSourcePaths), ...defaultExecutablePaths]
+                : [];
+        await Promise.all(candidates
+            .filter((path) => !kept.has(resolve(path)))
+            .map((path) => rm(path, { force: true })));
+    };
+    if (outputKind === "ir") {
+        await mkdir(dirname(opts.outPath), { recursive: true });
+        await writeFile(opts.outPath, serializeModule(lowered.module));
+        await removeStaleSourceArtifacts([opts.outPath]);
+        return { ok: true, artifact: { kind: "ir", path: opts.outPath } };
+    }
+    if (outputKind === "c") {
+        await mkdir(dirname(opts.outPath), { recursive: true });
+        await writeFile(opts.outPath, emitCModule(lowered.module, entryText));
+        await removeStaleSourceArtifacts([opts.outPath]);
+        return { ok: true, artifact: { kind: "c", path: opts.outPath } };
+    }
+    if (outputKind === "llvm" || outputKind === "asm" || outputKind === "obj") {
+        let llvm;
+        try {
+            llvm = emitLlvmModule(lowered.module, {
+                pointerBits: buildPlatform === "wasi" ? 32 : 64,
+                wasi: buildPlatform === "wasi",
+                runtimeAbiMarker: outputKind === "obj",
+            });
+        }
+        catch (err) {
+            if (!(err instanceof LlvmUnsupportedError))
+                throw err;
+            return { ok: false, diagnostics: [llvmRefusalDiag(err, entryPath)], sourceTexts };
+        }
+        if (outputKind === "llvm") {
+            await mkdir(dirname(opts.outPath), { recursive: true });
+            await writeFile(opts.outPath, llvm);
+        }
+        else {
+            try {
+                await emitNativeArtifact({
+                    outputPath: opts.outPath,
+                    llvm,
+                    outputKind,
+                    sourcePath: entryPath,
+                    optimization: opts.optimization === "dev" ? "0" : "2",
+                    ...(opts.sanitize === undefined ? {} : { sanitize: opts.sanitize }),
+                });
+            }
+            catch (err) {
+                if (!(err instanceof NativeCodegenError))
+                    throw err;
+                return {
+                    ok: false,
+                    diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)],
+                    sourceTexts,
+                };
+            }
+        }
+        await removeStaleSourceArtifacts([opts.outPath]);
+        if (outputKind === "obj" && opts.nativeLinkInfo === true) {
+            const target = nativeCodegenTarget();
+            if (target === null) {
+                throw new InternalCompilerError("native object emitted without a native target");
+            }
+            return {
+                ok: true,
+                artifact: {
+                    kind: "obj",
+                    path: opts.outPath,
+                    nativeLinkInfo: await createNativeLinkInfo({
+                        programObject: opts.outPath,
+                        target,
+                        features: executableNativeFeatures(lowered.module, "llvm", opts.dynamic ?? false, opts.optimization ?? "release"),
+                        ffi,
+                        optimization: opts.optimization ?? "release",
+                    }),
+                },
+            };
+        }
+        return { ok: true, artifact: { kind: outputKind, path: opts.outPath } };
+    }
     await mkdir(opts.outDir, { recursive: true });
-    const stem = basename(entryPath).replace(/\.(ts|js|mjs|cjs)$/, "");
     // Both backends hang off the same in-memory IrModule (never the JSON
     // dump); the LLVM backend's .ll takes the .c's seat on the exact clang
     // command line below — compileC accepts either. The default lane tries
     // LLVM first; a tier refusal retries ONLY the emit with the C backend
     // (the frontend ran once, the IR is backend-agnostic — nothing recompiles).
-    let cPath = join(opts.outDir, `${stem}.c`);
+    let cPath = defaultSourcePaths.c;
     let backend = "c";
+    let llvmSource = null;
     let llvmRefusal;
     if (opts.backend !== "c") {
         try {
             const ll = emitLlvmModule(lowered.module, {
                 pointerBits: buildPlatform === "wasi" ? 32 : 64,
                 wasi: buildPlatform === "wasi",
+                runtimeAbiMarker: opts.nativeProgramObject === true ||
+                    usesPrecompiledRuntimePack(opts, "llvm"),
             });
-            cPath = join(opts.outDir, `${stem}.ll`);
+            cPath = defaultSourcePaths.llvm;
             await writeFile(cPath, ll);
+            llvmSource = ll;
             backend = "llvm";
         }
         catch (err) {
@@ -760,120 +1279,72 @@ export async function compile(entryPath, opts) {
         }
     }
     if (backend === "c") {
-        await writeFile(cPath, emitModule(lowered.module, entryText));
+        await writeFile(cPath, emitCModule(lowered.module, entryText));
     }
     // Kept-TU honesty: outDir persists across builds (the CLI's .scriptc/),
     // so a lane change would leave the PREVIOUS lane's TU beside the fresh
     // one — remove the loser so the surviving TU is always the one the
     // binary below was linked from.
-    await rm(join(opts.outDir, `${stem}${backend === "llvm" ? ".c" : ".ll"}`), { force: true });
     let irPath;
     if (opts.emitIr) {
-        irPath = join(opts.outDir, `${stem}.ir.json`);
+        irPath = defaultSourcePaths.ir;
         await writeFile(irPath, serializeModule(lowered.module));
     }
+    await removeStaleSourceArtifacts([
+        cPath,
+        ...(irPath === undefined ? [] : [irPath]),
+    ]);
+    const nativeFeatures = executableNativeFeatures(lowered.module, backend, opts.dynamic ?? false, opts.optimization ?? "release", llvmRefusal);
+    const programSplit = backend === "llvm" && (opts.optimization ?? "release") === "dev" &&
+        !(opts.sanitize ?? false) && llvmSource !== null
+        ? splitLlvmProgram(llvmSource)
+        : null;
     await mkdir(dirname(opts.outPath), { recursive: true });
+    if (earlyCacheOptions === null) {
+        throw new InternalCompilerError("executable emission without executable cache options");
+    }
+    const executableCacheOptions = earlyCacheOptions;
+    let publishedExecutable = false;
+    let nativeProgramObject = null;
     try {
-        await compileC({
-            cPath,
-            outPath: opts.outPath,
-            // The emitted TU's non-system dependencies are the runtime/vendor tree,
-            // which cc.ts fingerprints separately. Low-level arbitrary C omits this
-            // opt-in so same-path header edits can never hit a stale artifact.
-            cacheIdentity: "scriptc-generated-v1",
-            sanitize: opts.sanitize ?? false,
-            dynamic: opts.dynamic ?? false,
-            // The link switch for scr_regex.c + libregexp: detected on the IR, so
-            // regex-free programs keep the historical (pinned) command line.
-            regex: moduleUsesRegex(lowered.module),
-            // Array copying methods and the typed-array bridges live in one
-            // optional TU, linked only when one of their IR intrinsics survives.
-            copying: moduleUsesCopying(lowered.module),
-            textDecoderLegacy: moduleUsesLegacyTextDecoder(lowered.module),
-            // FileHandle owns a native descriptor and its settled-promise adapters;
-            // keep that optional TU out of programs that never call fsp.open.
-            fileHandle: moduleUsesFileHandle(lowered.module),
-            // The link switch for scr_fetch.c (the native bridge over scr_net +
-            // scr_tls + scr_http's client parser + zlib — cc.ts implies those
-            // units into the link): embedded npm code that references fetch gets
-            // the bridge; everything else keeps its exact link line.
-            fetch: moduleUsesFetch(lowered.module),
-            // The island's node:http/https client bridge: embedded graphs that
-            // import those builtins pull scr_net_island.c + the socket units.
-            netIsland: moduleEmbedsBuiltin(lowered.module, "node:http") ||
-                moduleEmbedsBuiltin(lowered.module, "node:https") ||
-                moduleEmbedsBuiltin(lowered.module, "node:net") ||
-                moduleEmbedsBuiltin(lowered.module, "node:tls"),
-            // The link switch for scr_zlib.c + libz: zlib.* libCalls on the IR,
-            // node:zlib in the embedded graph, or COMPRESSED embedded module text
-            // (emit-island.ts stores big npm sources as raw DEFLATE; the emitted
-            // main installs scr_zlib_inflate_exact on the same predicate).
-            zlib: moduleUsesZlib(lowered.module) || moduleEmbedsCompressedNpm(lowered.module),
-            // The link switch for scr_assert.c: assert.* libCalls on the IR (the
-            // regex switch also pulls it — scr_regex.c calls the assert helpers).
-            assert: moduleUsesAssert(lowered.module),
-            // The link switch for scr_inspect.c: insp.* libCalls on the IR.
-            inspect: moduleUsesInspect(lowered.module),
-            // The link switch for scr_dyn_invoke.c: dynInvoke nodes or
-            // dyn.defineProps libCalls on the IR.
-            dynInvoke: moduleUsesDynInvoke(lowered.module),
-            // The link switch for scr_dc.c: dc.* libCalls on the IR (the
-            // diagnostics_channel registry and pub/sub).
-            dc: moduleUsesDc(lowered.module),
-            // The link switch for scr_async_dyn.c: the checked-dynamic async
-            // surfaces (cc.ts also pulls it under the dynInvoke/dc gates).
-            dynAsync: moduleUsesDynAsync(lowered.module),
-            // The link switch for scr_events.c: process signal/exit listeners and
-            // the stdin event surface on the IR.
-            events: moduleUsesProcessEvents(lowered.module),
-            // The link switch for scr_events_emitter.c: the node:events
-            // EventEmitter surface on the IR (emitter.* libCalls or the
-            // %EventEmitter class def).
-            emitter: moduleUsesEmitter(lowered.module),
-            // The link switch for scr_symbol.c: sym.* libCalls or a symbol-kind
-            // type anywhere on the IR.
-            symbol: moduleUsesSymbol(lowered.module),
-            // The link switch for scr_url_params.c: sp.* libCalls, the
-            // url.searchParams getter, or a searchParams-kind type on the IR.
-            searchParams: moduleUsesSearchParams(lowered.module),
-            // The link switch for scr_qs.c: the qs.* libCalls that live there
-            // (parse/stringify/unescape; escape rides the always-linked encoder).
-            qs: moduleUsesQs(lowered.module),
-            // The static node:util parseArgs implementation (scr_util.c).
-            parseArgs: moduleUsesParseArgs(lowered.module),
-            // The link switch for scr_stream.c: the node:stream class surface on
-            // the IR (stream libCalls or the %Readable-family class defs).
-            stream: moduleUsesStream(lowered.module),
-            // The link switch for scr_net.c: net.* (or http.* — http rides on
-            // net) libCalls on the IR.
-            net: moduleUsesNet(lowered.module),
-            // The link switch for scr_http.c: http.* libCalls on the IR.
-            http: moduleUsesHttpServer(lowered.module),
-            http2: moduleUsesHttp2(lowered.module),
-            // The link switch for scr_dgram.c: dgram.* or dns.* libCalls on the IR.
-            dgram: moduleUsesDgram(lowered.module),
-            // The link switch for scr_watch.c: fs.watch/watcher.* libCalls on the IR.
-            watch: moduleUsesFsWatch(lowered.module),
-            foreignFfi: hasForeignFfiCallback(lowered.module.ffiImports ?? []),
-            // The link switch for scr_test.c: test.* libCalls on the IR.
-            nodeTest: moduleUsesNodeTest(lowered.module),
-            // The link switch for scr_tls.c + the vendored mbedTLS archive:
-            // tls.* or https.* libCalls on the IR.
-            tls: moduleUsesTls(lowered.module),
-            // The link switch for scr_tls_ca.c (the CA-store introspection unit
-            // — plain PEM bookkeeping, no mbedTLS): tlsca.* libCalls on the IR.
-            // cc.ts also compiles it under the tls gate (scr_tls.c consults the
-            // unit's default-set override for its trust anchors).
-            tlsCa: moduleUsesTlsCa(lowered.module),
-            ...(ffi !== null
-                ? {
-                    linkInputs: ffi.libraries,
-                    systemLibraries: ffi.systemLibraries,
-                }
-                : {}),
+        const useRuntimePack = opts.nativeProgramObject === true ||
+            usesPrecompiledRuntimePack(opts, backend);
+        if (useRuntimePack) {
+            if (backend !== "llvm" || llvmSource === null) {
+                throw new InternalCompilerError("native program-object validation requires the LLVM backend");
+            }
+            try {
+                nativeProgramObject = await emitNativeProgramObject(entryPath, opts, llvmSource);
+            }
+            catch (err) {
+                if (!(err instanceof NativeCodegenError))
+                    throw err;
+                return {
+                    ok: false,
+                    diagnostics: [nativeCodegenDiag(err.diagnosticCode, err.message, entryPath)],
+                    sourceTexts,
+                };
+            }
+        }
+        await compileExecutableNative(nativeFeatures, nativeProgramObject?.linkPath ?? cPath, opts.outPath, opts.sanitize ?? false, ffi, programSplit, nativeProgramObject?.dependencies, opts.nativeProgramObject === true ? undefined : async ({ dependencies }) => {
+            await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
+                cPath,
+                native: nativeFeatures,
+                executableRestored: true,
+                nativeDependencies: dependencies,
+                frontend: frontendInputs.snapshot(),
+                ...(irPath === undefined ? {} : { irPath }),
+            });
+            publishedExecutable = true;
         });
+        if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
+            await rename(nativeProgramObject.linkPath, nativeProgramObject.artifactPath);
+        }
     }
     catch (err) {
+        if (err instanceof RuntimePackError) {
+            return { ok: false, diagnostics: [runtimePackDiagnostic(err, entryPath)], sourceTexts };
+        }
         if (ffi !== null && err instanceof CcCompileError) {
             return {
                 ok: false,
@@ -885,8 +1356,30 @@ export async function compile(entryPath, opts) {
         }
         throw err;
     }
+    finally {
+        if (nativeProgramObject !== null) {
+            await rm(nativeProgramObject.linkPath, { force: true }).catch(() => undefined);
+        }
+    }
+    if (!publishedExecutable) {
+        await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
+            cPath,
+            native: nativeFeatures,
+            executableRestored: false,
+            frontend: frontendInputs.snapshot(),
+            ...(irPath === undefined ? {} : { irPath }),
+        }).catch(() => undefined);
+    }
+    await pruneBuildCache(cacheRoot);
     return {
         ok: true,
+        artifact: {
+            kind: "exe",
+            path: opts.outPath,
+            translationUnitPath: cPath,
+            backend,
+            ...(llvmRefusal !== undefined ? { llvmRefusal } : {}),
+        },
         binaryPath: opts.outPath,
         cPath,
         backend,
@@ -1245,16 +1738,17 @@ async function compileLibraryNative(profile, cPath, archivePath, sanitize, featu
     const localizeSymbols = libraryLocalizeSymbols(profile);
     let identityCSource;
     let programSource;
-    if (profile.sidecar !== null || profile.emission === "c") {
+    if (profile.sidecar !== null || profile.emission === "c" ||
+        (profile.emission === "llvm" && profile.optimization === "dev" && !sanitize)) {
         const publicSource = await readFile(cPath, "utf8");
         programSource = publicSource;
     }
     if (profile.sidecar !== null) {
         if (features.buildId === undefined)
-            throw new Error("library identity TU has no build id");
+            throw new InternalCompilerError("library identity TU has no build id");
         const withoutIdentity = stripLibraryIdentity(programSource, profile.emission);
         if (withoutIdentity === programSource) {
-            throw new Error("generated public library TU has no identity region");
+            throw new InternalCompilerError("generated public library TU has no identity region");
         }
         programSource = withoutIdentity;
         identityCSource = [
@@ -1268,10 +1762,19 @@ async function compileLibraryNative(profile, cPath, archivePath, sanitize, featu
     if (profile.emission === "c") {
         programSource = stripLibrarySourceComments(programSource, profile.entry);
     }
+    const llvmSplit = profile.emission === "llvm" && profile.optimization === "dev" && !sanitize && programSource !== undefined
+        ? splitLlvmLibraryProgram(programSource)
+        : null;
     await compileLibArchive({
         cPath,
         ...(programSource !== undefined ? { programSource } : {}),
         ...(identityCSource !== undefined ? { identityCSource } : {}),
+        ...(llvmSplit !== null
+            ? {
+                programShards: llvmSplit.shards,
+                programPublicSymbols: llvmSplit.publicSymbols,
+            }
+            : {}),
         outPath: archivePath,
         cacheIdentity: "scriptc-generated-library-v1",
         sanitize,
@@ -1295,7 +1798,7 @@ async function emitSemanticLibraryHit(hit, profile, opts, archivePath, cacheRoot
     let sidecarJson = hit.sidecarJson;
     if (profile.sidecar !== null) {
         if (mod.lib?.identity === undefined || sidecarJson === null) {
-            throw new Error("semantic library cache lost sidecar identity metadata");
+            throw new InternalCompilerError("semantic library cache lost sidecar identity metadata");
         }
         const modules = canonicalModuleGraph(rootDir, hit.sourceTexts);
         const { buildId, sourceHash } = libraryIdentityHashes(compilerReleaseVersion(), profile.profileBytes, modules);
@@ -1312,7 +1815,7 @@ async function emitSemanticLibraryHit(hit, profile, opts, archivePath, cacheRoot
         };
     }
     await mkdir(opts.outDir, { recursive: true });
-    const stem = basename(profile.entry).replace(/\.(ts|js|mjs|cjs)$/, "");
+    const stem = basename(profile.entry).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
     const cPath = join(opts.outDir, `${stem}.lib.${profile.emission === "llvm" ? "ll" : "c"}`);
     let translationUnit = hit.translationUnit;
     if (profile.sidecar !== null) {
@@ -1325,7 +1828,7 @@ async function emitSemanticLibraryHit(hit, profile, opts, archivePath, cacheRoot
         const previous = hit.previousSources.get(mod.sourceFile);
         const current = hit.sourceTexts.get(mod.sourceFile);
         if (previous === undefined || current === undefined) {
-            throw new Error("semantic library cache lost the entry source text");
+            throw new InternalCompilerError("semantic library cache lost the entry source text");
         }
         translationUnit = rebaseLibrarySourceComments(translationUnit, mod.sourceFile, createSourceLineRebaser(mod.sourceFile, previous, current));
         await writeFile(cPath, translationUnit);
@@ -1367,6 +1870,7 @@ async function emitSemanticLibraryHit(hit, profile, opts, archivePath, cacheRoot
     };
 }
 export async function compileLibrary(opts) {
+    clearCompileSessionCaches();
     const frontendInputs = new FrontendInputTracker();
     return frontendInputs.run(() => compileLibraryTracked(opts, frontendInputs));
 }
@@ -1409,7 +1913,7 @@ async function compileLibraryTracked(opts, frontendInputs) {
         if (directory === profileDir || dirname(directory) === directory)
             break;
     }
-    const archivePath = opts.outPath ?? join(opts.outDir, `${basename(entryPath).replace(/\.(ts|js|mjs|cjs)$/, "")}.lib.a`);
+    const archivePath = opts.outPath ?? join(opts.outDir, `${basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "")}.lib.a`);
     // Mobile-target admission first — a pure env/host check, so a refused
     // pairing never reaches toolchain discovery. iOS targets (device and
     // simulator) build on darwin hosts only: the Apple SDK sysroot and the
@@ -1429,7 +1933,7 @@ async function compileLibraryTracked(opts, frontendInputs) {
     // Multi-instance library mode (abi.localize_runtime) localizes per
     // OBJECT FORMAT: ELF and COFF archives localize from any host (cross
     // ELF merges through the cross driver's own lld; COFF merges and
-    // demotes in process — see cc.ts's localizeLibraryObjects), and Mach-O
+    // demotes in process — see native-toolchain.ts's localizeLibraryObjects), and Mach-O
     // localization runs the macOS host linker, so macos and ios targets
     // admit darwin hosts only (the mobile admission above already refused
     // an ios triple off darwin). Everything else refuses before frontend/
@@ -1726,7 +2230,7 @@ async function compileLibraryTracked(opts, frontendInputs) {
         return fail(validation.map((v) => iceDiag(v.message, v.loc)));
     timing("ir-validate");
     await mkdir(opts.outDir, { recursive: true });
-    const stem = basename(entryPath).replace(/\.(ts|js|mjs|cjs)$/, "");
+    const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
     let cPath;
     if (profile.emission === "llvm") {
         try {
@@ -1745,7 +2249,7 @@ async function compileLibraryTracked(opts, frontendInputs) {
     }
     else {
         cPath = join(opts.outDir, `${stem}.lib.c`);
-        await writeFile(cPath, emitModule(mod, entryText));
+        await writeFile(cPath, emitCModule(mod, entryText));
     }
     await rm(join(opts.outDir, `${stem}.lib.${profile.emission === "llvm" ? "c" : "ll"}`), { force: true });
     let irPath;