@scriptc/compiler 0.0.35 → 0.1.1

package/dist/index.js

@@ -1,57 +1,72 @@
-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, executableNativeEnvironmentFingerprint, mobileLibraryTarget, mobileTargetRefusal, prepareBuildCacheRoot, pruneBuildCache, resolveCc, targetPlatform } from "./backend/cc.js";
-import { emitModule } from "./backend/emission/emitter.js";
+import { clearCcCaches, configuredTargetPlatform } from "./backend/native-toolchain.js";
+import { buildCacheRoot, prepareBuildCacheRoot, pruneBuildCache } from "./backend/build-cache.js";
+import { assertLegacyCExecutablePipelineEnabled, CcCompileError, compileExternalC, compileExternalCLibrary, executableNativeEnvironmentFingerprint, legacyCExecutablePathRequested, mobileLibraryTarget, mobileTargetRefusal, resolveCc, targetPlatform, } from "./backend/external-c.js";
+import { emitCModule } from "./backend/c/c-emitter.js";
 import { emitLlvmModule, LlvmUnsupportedError } from "./backend/llvm/emitter.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 { RuntimePackError } from "./backend/runtime-pack.js";
+import { createNativeLinkPlan } from "./backend/link-plan.js";
+import { executableLinkerEnvironmentFingerprint, linkNativeExecutable, platformLinkerSupportsPersistentCache, resolvePlatformLinker, } from "./backend/linker.js";
 import { splitLlvmLibraryProgram, splitLlvmProgram } from "./backend/llvm/split.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 { 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/early-cache.js";
-import { compilerImplementationIdentity } from "./library/implementation-identity.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, warmNativeCaches, } 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 { compileExternalC as compileC, compileExternalC, runtimeSrcDir, warmNativeCaches, } from "./backend/external-c.js";
+export { ANDROID_MIN_API, IPHONEOS_MIN_VERSION, isAndroidTarget, isIosTarget, isMobileTarget, mobileLibraryTarget, mobileTargetRefusal } from "./backend/external-c.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";
 export { BUILD_ID_SEED, SOURCE_HASH_SEED, hex16, lengthPrefixedStream, wyhash64 } from "./library/wyhash.js";
-export { ISLAND_SURFACE } from "./frontend/lowering/surfaces.js";
+export { ISLAND_SURFACE, STATIC_MATH_PROPS } from "./frontend/lowering/surfaces.js";
 export { ambientDtsPath, isExactExternalTypeSpecifier, overridesDtsPath } from "./frontend/program.js";
 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
@@ -200,6 +215,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
@@ -297,8 +318,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);
     }
@@ -309,13 +329,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
@@ -370,7 +383,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);
@@ -631,10 +644,35 @@ 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,
@@ -674,60 +712,156 @@ function executableNativeFeatures(mod, backend, dynamic, optimization, llvmRefus
         tlsCa: moduleUsesTlsCa(mod),
     };
 }
-async function compileExecutableNative(features, cPath, outPath, sanitize, ffi, programSplit = null, onArtifactReady) {
+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 createNativeLinkPlan({
+            target: runtimePackTarget,
+            programObject: cPath,
+            outPath,
+            features,
+            ffi,
+            optimization: features.optimization ?? "release",
+            programObjectDependencies,
+        });
+        const cacheableLinker = onArtifactReady !== undefined && ffi === null && platformLinkerSupportsPersistentCache(process.env, runtimePackTarget);
+        await linkNativeExecutable(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 ??
-        (features.optimization === "dev" && features.backend === "llvm" && !sanitize
+        (!programIsObject && features.optimization === "dev" && features.backend === "llvm" && !sanitize
             ? splitLlvmProgram(await readFile(cPath, "utf8"))
             : null);
-    await compileC({
-        cPath,
-        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
-            ? {}
-            : { linkInputs: ffi.libraries, systemLibraries: ffi.systemLibraries }),
-    });
+    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 {
+        assertLegacyCExecutablePipelineEnabled();
+        await compileExternalC({
+            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" || legacyCExecutablePathRequested())
+        return false;
+    return 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) {
@@ -739,12 +873,64 @@ async function compileTracked(entryPath, opts, frontendInputs) {
         ffi = loaded.profile;
         ffiProfileBytes = loaded.profileBytes;
     }
-    const buildPlatform = buildTargetPlatform();
+    let buildPlatform;
+    if (outputKind === "exe") {
+        // Target semantics are needed before choosing the helper/runtime-pack
+        // path. Do not make them contingent on the legacy C-driver resolver:
+        // an LLVM-owned WASI build deliberately needs no SCRIPTC_CC.
+        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(),
+            };
+        }
+    }
+    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(),
+                };
+            }
+        }
+    }
     // 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) {
@@ -766,40 +952,72 @@ async function compileTracked(entryPath, opts, frontendInputs) {
             };
         }
     }
-    const cacheRoot = provenanceSources() === null
+    const cacheRoot = outputKind === "exe" && provenanceSources() === null
         ? await prepareBuildCacheRoot(buildCacheRoot())
         : null;
-    const implementation = await compilerImplementationIdentity();
-    const 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}`,
-        compiler: [process.env["SCRIPTC_CC"] ?? "clang"],
-        nativeEnvironment: await executableNativeEnvironmentFingerprint(),
-        nodeVersion: process.version,
-        implementation: implementation.digest,
-        implementationDependencies: implementation.dependencies,
-    };
-    const earlyHit = await readEarlyExecutableCache(cacheRoot, earlyCacheOptions);
+    let earlyCacheOptions = null;
+    if (outputKind === "exe") {
+        const implementation = await compilerImplementationIdentity();
+        const helperObjectRoute = opts.nativeProgramObject === true ||
+            (opts.backend !== "c" && usesPrecompiledRuntimePack(opts, "llvm"));
+        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"
+                : helperObjectRoute ? "runtime-pack" : "driver-tu"}`,
+            compiler: [
+                helperObjectRoute
+                    ? resolvePlatformLinker(process.env, nativeCodegenTarget()?.defaultLinker)
+                    : (process.env["SCRIPTC_CC"] ?? "clang"),
+            ],
+            nativeEnvironment: helperObjectRoute
+                ? await executableLinkerEnvironmentFingerprint(process.env, nativeCodegenTarget()?.defaultLinker)
+                : 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, earlyCacheOptions).catch(() => undefined);
+        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,
@@ -809,17 +1027,45 @@ async function compileTracked(entryPath, opts, frontendInputs) {
                     : { 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, earlyHit.cPath, opts.outPath, opts.sanitize ?? false, ffi, null, async ({ dependencies }) => {
-                await publishEarlyExecutableCache(cacheRoot, earlyCacheOptions, {
+            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,
@@ -829,9 +1075,23 @@ async function compileTracked(entryPath, opts, frontendInputs) {
             }
             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,
@@ -890,7 +1150,7 @@ async function compileTracked(entryPath, opts, frontendInputs) {
             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([
@@ -905,14 +1165,114 @@ async function compileTracked(entryPath, opts, frontendInputs) {
     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;
@@ -921,8 +1281,10 @@ async function compileTracked(entryPath, opts, frontendInputs) {
             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";
@@ -939,28 +1301,55 @@ async function compileTracked(entryPath, opts, frontendInputs) {
         }
     }
     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 compileExecutableNative(nativeFeatures, cPath, opts.outPath, opts.sanitize ?? false, ffi, programSplit, async ({ dependencies }) => {
-            await publishEarlyExecutableCache(cacheRoot, earlyCacheOptions, {
+        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,
@@ -970,8 +1359,14 @@ async function compileTracked(entryPath, opts, frontendInputs) {
             });
             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,
@@ -983,8 +1378,13 @@ async function compileTracked(entryPath, opts, frontendInputs) {
         }
         throw err;
     }
+    finally {
+        if (nativeProgramObject !== null) {
+            await rm(nativeProgramObject.linkPath, { force: true }).catch(() => undefined);
+        }
+    }
     if (!publishedExecutable) {
-        await publishEarlyExecutableCache(cacheRoot, earlyCacheOptions, {
+        await publishEarlyExecutableCache(cacheRoot, executableCacheOptions, {
             cPath,
             native: nativeFeatures,
             executableRestored: false,
@@ -995,6 +1395,13 @@ async function compileTracked(entryPath, opts, frontendInputs) {
     await pruneBuildCache(cacheRoot);
     return {
         ok: true,
+        artifact: {
+            kind: "exe",
+            path: opts.outPath,
+            translationUnitPath: cPath,
+            backend,
+            ...(llvmRefusal !== undefined ? { llvmRefusal } : {}),
+        },
         binaryPath: opts.outPath,
         cPath,
         backend,
@@ -1360,10 +1767,10 @@ async function compileLibraryNative(profile, cPath, archivePath, sanitize, featu
     }
     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 = [
@@ -1380,7 +1787,7 @@ async function compileLibraryNative(profile, cPath, archivePath, sanitize, featu
     const llvmSplit = profile.emission === "llvm" && profile.optimization === "dev" && !sanitize && programSource !== undefined
         ? splitLlvmLibraryProgram(programSource)
         : null;
-    await compileLibArchive({
+    await compileExternalCLibrary({
         cPath,
         ...(programSource !== undefined ? { programSource } : {}),
         ...(identityCSource !== undefined ? { identityCSource } : {}),
@@ -1413,7 +1820,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);
@@ -1430,7 +1837,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) {
@@ -1443,7 +1850,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);
@@ -1485,6 +1892,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));
 }
@@ -1527,7 +1935,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
@@ -1547,7 +1955,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/
@@ -1844,7 +2252,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 {
@@ -1863,7 +2271,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;