@scriptc/compiler 0.4.6 → 0.4.8

package/dist/index.js

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import { setShapeOverlayMemoDir, shapeOverlayEnabled } from "./frontend/shape-inference/index.js";
-import { nodeFrontendServices } from "./frontend/services-node.js";
+import { jsInferenceEnabled } from "./frontend/js-inference.js";
+import { beginCompileServices, compileFrontendServices, createNodeFrontendServices, endCompileServices, nodeFrontendServices, } from "./frontend/services-node.js";
 import { runTypePatchCommand, } from "./frontend/type-patches/command.js";
 import { optimizationField } from "./backend/optimization.js";
 import { targetCpuField, targetCpuTargetRefusal } from "./backend/target-cpu.js";
@@ -14,6 +15,7 @@ import { checkerCacheIdentity } from "./frontend/ts7/checker-backend.js";
 import { setLibDiagnosticsStore } from "./frontend/ts7/lib-diagnostics.js";
 import { analyzeWithVerdictCache, fileVerdictStore } from "./coverage/verdict-cache.js";
 import { coverageCompilerIdentity } from "./coverage/verdict-startup.js";
+import { directoryUnitStore, unitReuseEnabled, } from "./frontend/lowering/unit-reuse.js";
 import { commentOnlyReplay } from "./coverage/verdict-semantic.js";
 import { llvmRefusalDiag, targetRefusalDiag } from "./backend/target-diagnostics.js";
 import { compilePackedLibrary } from "./backend/library-pack.js";
@@ -41,10 +43,10 @@ import { privateSiblingPath } from "./backend/build-cache.js";
 import { nativeCodegenTarget, nativeCodegenTargetRefusal, staticLinkRefusal, } from "./backend/targets.js";
 import { windowsSubsystemLinkerArgs } from "./backend/targets.js";
 import { createNativeLinkInfo } from "./backend/native-link-info.js";
-import { RuntimePackError } from "./backend/runtime-pack.js";
+import { RuntimePackError, loadRuntimePack, } from "./backend/runtime-pack.js";
 import { createNativeLinkPlan } from "./backend/link-plan.js";
 import { nativeProfileKey, nativeProfileLayout, nativeProfileRefusal, profileBlocksPath, profileHasContextCounts, recordProfileBlocksPath, } from "./backend/native-profile.js";
-import { executableLinkerEnvironmentFingerprint, linkNativeExecutable, platformLinkerSupportsPersistentCache, resolvePlatformLinker, } from "./backend/linker.js";
+import { executableLinkerEnvironmentFingerprint, installRuntimeDataFiles, linkNativeExecutable, platformLinkerSupportsPersistentCache, resolvePlatformLinker, } from "./backend/linker.js";
 import { splitLlvmLibraryProgram, splitLlvmProgram, splitLlvmProgramFile, } from "./backend/llvm/split.js";
 import { emitLibraryIdentityLines, replaceLibraryIdentity, stripLibraryIdentity, } from "./backend/library-identity-markers.js";
 import { ffiNativeBuildDiag, iceDiag, nativeCodegenDiag, nodeIslandNodeDiag, nodeIslandModuleDiag, isTypePatchCode, } from "./diagnostics/diagnostic.js";
@@ -55,12 +57,13 @@ import { loadLibraryProfile } from "./library/library-profile.js";
 import { clearFenceEvalCaches, decorateLibraryRefusals } from "./library/fence-eval.js";
 import { canonicalModuleGraph, clearSidecarCaches, compilerReleaseVersion, libraryIdentityHashes, updateSidecarIdentity, } from "./library/sidecar.js";
 import {} from "./ir/ir.js";
-import { moduleRuntimeFeatures } from "./ir/runtime-features.js";
+import { jsObjectModelFact, moduleRuntimeFeatures } from "./ir/runtime-features.js";
 import { serializeModuleParts } from "./ir/serialize.js";
 import { readTextParts, writeTextParts } from "./text-parts.js";
 import { validateModule } from "./ir/validate.js";
 import { compilerOwnedFileRoots } from "./frontend/dts-paths.js";
-import { loadProgram } from "./frontend/program-node.js";
+import { loadProgramWithServices } from "./frontend/program-node.js";
+import { programHostLoads } from "./frontend/services.js";
 import { runFrontend } from "./frontend/pipeline.js";
 import { provenanceSources, setProvenanceSources, } from "./frontend/provenance-registry.js";
 import { clearResolveCaches } from "./frontend/resolve.js";
@@ -68,6 +71,7 @@ import { loadFfiProfile } from "./ffi/ffi-manifest.js";
 import { executableLinkFeatures } from "./backend/executable-features.js";
 import { youngNurseryRequested } from "./backend/young-nursery.js";
 import { heapCensusRequested } from "./backend/llvm/heap-census.js";
+import { debugJsIcWays } from "./backend/llvm/js-ic.js";
 import { representationReportPath } from "./backend/llvm/repr-report.js";
 import { FrontendInputTracker, trackedReadFile, } from "./frontend/input-tracker.js";
 import { libraryFrontendImplementationFingerprint, publishEarlyLibraryCache, readEarlyLibraryCache, readSemanticLibraryCache, } from "./library/library-cache.js";
@@ -139,7 +143,16 @@ export function sourceTargetPlatform(env = process.env) {
     return configuredTargetPlatform(env);
 }
 export function analyze(entryPath, opts = {}) {
-    return analyzeWithFrontend(entryPath, opts, buildTargetPlatform(), nodeFrontend);
+    // One scope for the whole analysis: its island reload and retry lowerings
+    // load the program again, and they reuse the checker that answered the
+    // first load instead of starting a cold one.
+    const services = beginCompileServices();
+    try {
+        return analyzeWithFrontend(entryPath, opts, buildTargetPlatform(), nodeFrontend);
+    }
+    finally {
+        endCompileServices(services);
+    }
 }
 /** analyze() behind the coverage verdict cache (the CLI's `scriptc
  * coverage`): an unchanged program, or one whose TypeScript edits only
@@ -167,7 +180,37 @@ export async function analyzeCached(entryPath, opts = {}) {
 // Island code resolves through Node (node-islands/resolve.ts; the
 // self-hosted compiler builds no islands).
 setIslandResolver((fromFile, spec) => createRequire(fromFile).resolve(spec));
-const nodeFrontend = (entry, npmStatic, externalTypes, libraryNpmStatic, options) => runFrontend(entry, loadProgram, npmStatic, externalTypes, libraryNpmStatic, options);
+const nodeFrontend = (entry, npmStatic, externalTypes, libraryNpmStatic, options) => {
+    // One syntax parser for every load of this compile, and program hosts
+    // that serve several loads (FrontendServices.reuseProgramHosts). Inside a
+    // compile scope (beginCompileServices) the later frontends — the island
+    // reload and each retry round's loads — share the hosts this one leaves
+    // idle instead of starting a cold checker each.
+    const shared = compileFrontendServices();
+    const services = shared ?? createNodeFrontendServices();
+    try {
+        services.reuseProgramHosts(programHostLoads());
+        const frontend = runFrontend(entry, (path, loadOptions) => loadProgramWithServices(path, services, loadOptions), npmStatic, externalTypes, libraryNpmStatic, options);
+        return {
+            ...frontend,
+            dispose: () => {
+                try {
+                    frontend.dispose();
+                }
+                finally {
+                    // A shared scope closes its services when the compile ends.
+                    if (shared === null)
+                        services.close();
+                }
+            },
+        };
+    }
+    catch (error) {
+        if (shared === null)
+            services.close();
+        throw error;
+    }
+};
 /** The checker's part of the executable cache key (`checkerCacheIdentity`), as the CLI's startup route computes it. */
 function checkerField() {
     const checker = checkerCacheIdentity();
@@ -222,6 +265,12 @@ function cachedWarningSources(warnings) {
     }
     return texts;
 }
+/** The Node islands a build ran, stored with its cache entry so a cache hit
+ * reports them again (a runner reads them to tell an island pass from a
+ * native one). */
+function islandFields(sink) {
+    return sink?.islands === undefined ? {} : { islands: sink.islands };
+}
 /** The build's performance warnings (SC61xx), stored with its cache entry
  * so a cache hit repeats them. */
 function performanceWarnings(sink) {
@@ -235,10 +284,23 @@ function performanceWarnings(sink) {
 function profileMatchField(object) {
     return object?.profileMatch === undefined ? {} : { profileMatch: object.profileMatch };
 }
+/** The partitions a divided module's executable was linked from, for its
+ * executable cache entry (executable/executable-cache.ts). */
+function partitionsField(object) {
+    return object?.partitions === undefined ? {} : { partitions: object.partitions };
+}
 function withCompileWarnings(result, sink) {
-    if (!result.ok || sink.warnings.length === 0)
+    if (!result.ok)
         return result;
-    return { ...result, warnings: sink.warnings, sourceTexts: sink.sourceTexts ?? new Map() };
+    const islands = sink.islands === undefined ? {} : { islands: sink.islands };
+    if (sink.warnings.length === 0)
+        return { ...result, ...islands };
+    return {
+        ...result,
+        warnings: sink.warnings,
+        sourceTexts: sink.sourceTexts ?? new Map(),
+        ...islands,
+    };
 }
 /** Build-time API compatibility fence: a caller's existing CompileOptions
  * variable must retain the executable result aliases without narrowing. */
@@ -259,11 +321,57 @@ function assertCompileResultCompatibility(result) {
 }
 void assertCompileResultCompatibility;
 function executableNativeFeatures(mod, backend, optimization, largePages) {
-    return {
+    const features = {
         backend,
         ...optimizationField(optimization),
         ...executableLinkFeatures(mod, largePages),
     };
+    // The executable cache record spells every boolean key (BOOLEAN_NATIVE_KEYS
+    // in executable-cache.ts), and mutableBuffers is optional in the link
+    // features so that a program without the fact keeps its link identity.
+    return { ...features, mutableBuffers: features.mutableBuffers === true };
+}
+/** Install the run-time data files of the selected runtime pack beside an
+ * executable this build linked while features.intl is true (ICU's
+ * icudt78l.dat). Every path that produces an Intl executable calls it: the
+ * pack link path installs them from its own selection (linker.ts), and the
+ * C-source path — sanitized builds, and links that do not start from a
+ * program object — compiles the runtime itself and would otherwise leave a
+ * binary whose Intl forms throw at run time for want of data. */
+async function installRuntimeDataBesideExecutable(features, outPath) {
+    const pack = await intlRuntimePack(features);
+    if (pack !== null)
+        await installRuntimeDataFiles(pack, outPath);
+}
+/** The host target's runtime pack selection for an Intl program, or null
+ * when the program does not use Intl or the build has no host target. */
+async function intlRuntimePack(features) {
+    if (features.intl !== true)
+        return null;
+    const target = nativeCodegenTarget();
+    if (target === null)
+        return null;
+    return loadRuntimePack({
+        target,
+        features,
+        optimization: features.optimization ?? "release",
+    });
+}
+/** The pack's ICU archive and the include root of the ICU headers it ships
+ * (`<root>/unicode/*.h`), both verified by loadRuntimePack, for the
+ * C-source path to link and compile scr_intl.c against. Null when the pack
+ * lists no headers: that path then builds ICU from its fetched release. */
+function runtimePackIcuInputs(pack) {
+    if (pack === null)
+        return null;
+    const header = pack.selectedHeaderArtifacts[0];
+    const index = pack.selectedArchiveArtifacts.findIndex((artifact) => "id" in artifact && artifact.id === "icu");
+    if (header === undefined || index < 0)
+        return null;
+    return {
+        archive: pack.archives[index],
+        include: join(pack.root, dirname(dirname(header.path))),
+    };
 }
 async function compileExecutableNative(features, llvmPath, outPath, sanitize, ffi, windowsSubsystem, strip, staticLink = false, programSplit = null, programObjectDependencies = [], onArtifactReady, programPartitions = [], profileGenerate = false, 
 /** The kept LLVM text's shared name, when `llvmPath` is the build's private copy of it
@@ -309,6 +417,8 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         throw new InternalCompilerError("program objects must link against a precompiled runtime pack");
     if (staticLink)
         throw new InternalCompilerError("--static executables link against a precompiled runtime pack");
+    const intlPack = await intlRuntimePack(features);
+    const icuPack = runtimePackIcuInputs(intlPack);
     await compileExternalC({
         ...(llvmVisiblePath === undefined || llvmVisiblePath === llvmPath
             ? { cPath: llvmPath }
@@ -328,29 +438,46 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         regex: features.regex,
         copying: features.copying,
         textDecoderLegacy: features.textDecoderLegacy,
+        bigintBytes: features.bigintBytes,
         fileHandle: features.fileHandle,
         fetch: features.fetch,
         ...(features.eventTarget ? { eventTarget: true } : {}),
         ...(features.wasm ? { wasm: true } : {}),
         ...(features.warningReplace ? { warningReplace: true } : {}),
+        ...(jsObjectModelFact(features) ? { jsObjectModel: true } : {}),
+        ...(features.mutableBuffers === true ? { mutableBuffers: true } : {}),
         ...(features.stdioExtended ? { stdioExtended: true } : {}),
+        ...(features.fsFlags ? { fsFlags: true } : {}),
+        ...(features.strdecDyn ? { strdecDyn: true } : {}),
+        ...(features.processExtras ? { processExtras: true } : {}),
+        ...(features.streamWriteErrors ? { streamWriteErrors: true } : {}),
+        ...(features.stdioWriteSlot ? { stdioWriteSlot: true } : {}),
         ...(features.nodeIsland ? { nodeIsland: true } : {}),
         ...(features.moduleNamespace ? { moduleNamespace: true } : {}),
         ...(features.moduleNamespaceDyn ? { moduleNamespaceDyn: true } : {}),
+        ...(features.primitiveWrapper ? { primitiveWrapper: true } : {}),
+        ...(features.iteratorProto ? { iteratorProto: true } : {}),
         zlib: features.zlib,
         ...(features.brotli ? { brotli: true } : {}),
+        ...(features.zstd ? { zstd: true } : {}),
+        ...(features.intl ? { intl: true } : {}),
+        ...(icuPack === null ? {} : { icuPack }),
         assert: features.assert,
         inspect: features.inspect,
         dynInvoke: features.dynInvoke,
         dc: features.dc,
         dynAsync: features.dynAsync,
         ...(features.dynTier ? { dynTier: true } : {}),
+        ...(features.promiseGeneric ? { promiseGeneric: true } : {}),
         ...(features.streamDyn ? { streamDyn: true } : {}),
         ...(features.handleProps ? { handleProps: true } : {}),
         ...(features.childLifecycle ? { childLifecycle: true } : {}),
+        ...(features.childOptionExt ? { childOptionExt: true } : {}),
         ...(features.declAdopt ? { declAdopt: true } : {}),
         ...(features.typeOrigins ? { typeOrigins: true } : {}),
         ...(features.dynForAwait ? { dynForAwait: true } : {}),
+        ...(features.dynIntegrityQueries ? { dynIntegrityQueries: true } : {}),
+        ...(features.genBind ? { genBind: true } : {}),
         ...(features.eventsOnceSignal ? { eventsOnceSignal: true } : {}),
         ...(features.mime ? { mime: true } : {}),
         ...(features.largePages ? { largePages: true } : {}),
@@ -359,6 +486,10 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         ...(features.utilTiming ? { utilTiming: true } : {}),
         ...(features.dynBuffer ? { dynBuffer: true } : {}),
         ...(features.builtinValues ? { builtinValues: true } : {}),
+        ...(features.stdlibPrototypeValue ? { stdlibPrototypeValue: true } : {}),
+        ...(features.hostAbsentGlobals ? { hostAbsentGlobals: true } : {}),
+        ...(features.arrayLikeDispatch ? { arrayLikeDispatch: true } : {}),
+        ...(features.builtinPrototypeValue ? { builtinPrototypeValue: true } : {}),
         ...(features.computedRequire ? { computedRequire: true } : {}),
         events: features.events,
         emitter: features.emitter,
@@ -380,6 +511,7 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         dgramDyn: features.dgramDyn,
         textCodecDyn: features.textCodecDyn,
         watch: features.watch,
+        watchFile: features.watchFile,
         foreignFfi: features.foreignFfi,
         ...(features.workers ? { workers: true } : {}),
         ...(features.youngNursery ? { youngNursery: true } : {}),
@@ -403,6 +535,8 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
                 frameworks: ffi.frameworks,
             }),
     });
+    if (intlPack !== null)
+        await installRuntimeDataFiles(intlPack, outPath);
 }
 async function emitNativeProgramObject(entryPath, opts, llvm, profile) {
     const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
@@ -427,9 +561,13 @@ async function emitNativeProgramObject(entryPath, opts, llvm, profile) {
             partitions,
             ...(profile === undefined ? {} : { profile }),
         });
+        // A divided module's count depends on the host's thread count, which chose
+        // it, so the executable cache entry records the count a later build
+        // compares again (executable/executable-cache.ts).
         return {
             linkPath,
             partitionPaths: artifact.outputPaths.slice(1),
+            ...(single ? {} : { partitions }),
             artifactPath,
             dependencies: artifact.dependencies,
             ...(artifact.profileMatch === undefined ? {} : { profileMatch: artifact.profileMatch }),
@@ -513,11 +651,50 @@ function usesPrecompiledRuntimePack(opts, backend) {
 function runtimePackDiagnostic(error, entryPath) {
     return nativeCodegenDiag(error.code === "unsupported" ? "SC3002" : "SC3003", error.message, entryPath, error.hint);
 }
+/** The unit store of a Node-hosted build (unit-reuse.ts), keyed by the
+ * compiler, the entry, the options that reach lowering and the target
+ * platform. */
+async function nodeUnitStore(entryPath, opts, ffi, buildPlatform) {
+    if (!unitReuseEnabled() || provenanceSources() !== null)
+        return null;
+    const root = await prepareBuildCacheRoot(buildCacheRoot());
+    if (root === null)
+        return null;
+    const directory = join(root, "units-v1");
+    const implementation = await coverageCompilerIdentity(directory);
+    if (implementation === null)
+        return null;
+    const { outPath: _outPath, outDir: _outDir, ...lowering } = opts;
+    const key = createHash("sha256")
+        .update(JSON.stringify({
+        schema: 1,
+        entry: resolve(entryPath),
+        options: lowering,
+        ffi,
+        platform: buildPlatform,
+        compiler: implementation.digest,
+    }))
+        .digest("hex");
+    return directoryUnitStore(directory, key);
+}
 /** Finish frontend work in a separate scope so the AST, checker caches and
  * typed IR can be reclaimed before the native optimizer needs its heap. */
 async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timing, warningSink) {
     const outputKind = opts.outputKind ?? "exe";
-    const prepared = prepareExecutableModule(entryPath, opts, ffi, buildPlatform, nodeFrontend, timing);
+    // The frontend loads of one build — the island decision's reload and every
+    // retry round's load — share one services scope, so each load after the
+    // first rebinds the checker the previous one leaves idle instead of
+    // starting a cold one. The scope ends with the last load: LLVM emission and
+    // native code generation run after it, and no idle checker process holds
+    // its heap through them.
+    const services = beginCompileServices();
+    let prepared;
+    try {
+        prepared = prepareExecutableModule(entryPath, opts, ffi, buildPlatform, nodeFrontend, timing, new Map(), true, await nodeUnitStore(entryPath, opts, ffi, buildPlatform));
+    }
+    finally {
+        endCompileServices(services);
+    }
     if (!prepared.ok)
         return prepared;
     const { mod, sourceTexts } = prepared;
@@ -571,6 +748,8 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         warningSink.warnings = prepared.warnings;
         warningSink.sourceTexts = sourceTexts;
     }
+    if (warningSink !== undefined && prepared.islands !== undefined)
+        warningSink.islands = prepared.islands;
     const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
     const defaultSourcePaths = {
         ir: join(opts.outDir, `${stem}.ir.json`),
@@ -719,6 +898,7 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         nativeFeatures,
         programSplit,
         sourceTexts,
+        ...(prepared.islands === undefined ? {} : { islands: prepared.islands }),
     };
 }
 /** Moves a build's private copies to the shared names, or drops them when that fails. */
@@ -887,6 +1067,8 @@ async function prepareExecutableInputInChild(frontendProcess, entryPath, opts, f
         warningSink.warnings = result.warnings;
         warningSink.sourceTexts = sourceTexts;
     }
+    if (warningSink !== undefined && result.kind === "prepared" && result.islands !== undefined)
+        warningSink.islands = result.islands;
     if (result.kind === "diagnostics")
         return { ok: false, diagnostics: result.diagnostics, sourceTexts };
     return {
@@ -898,6 +1080,7 @@ async function prepareExecutableInputInChild(frontendProcess, entryPath, opts, f
         nativeFeatures: result.nativeFeatures,
         programSplit: null,
         sourceTexts,
+        ...(result.islands === undefined ? {} : { islands: result.islands }),
     };
 }
 /**
@@ -961,6 +1144,7 @@ export async function runFrontendProcess(requestPath, resultPath) {
                 nativeFeatures: prepared.nativeFeatures,
                 sourceTexts: [...prepared.sourceTexts],
                 warnings: warnings.warnings,
+                ...(prepared.islands === undefined ? {} : { islands: prepared.islands }),
                 frontend,
             };
         }
@@ -1232,6 +1416,8 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
     let earlyCacheOptions = null;
     if (outputKind === "exe") {
         const helperObjectRoute = opts.nativeProgramObject === true || usesPrecompiledRuntimePack(opts, "llvm");
+        // An attribution build emits different code, so it is its own cache entry.
+        const jsIcWays = debugJsIcWays();
         const routeOptions = {
             entryPath,
             outDir: opts.outDir,
@@ -1262,6 +1448,10 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             ...(heapCensusRequested() ? { heapCensus: true } : {}),
             npmStatic: opts.npmStatic ?? null,
             ...(shapeOverlayEnabled() ? { shapeOverlay: true } : {}),
+            ...(jsInferenceEnabled() && process.env["SCRIPTC_SHAPE_OVERLAY"] !== "0"
+                ? { jsInference: true }
+                : {}),
+            ...(jsIcWays === null ? {} : { jsIcWays }),
             ffiProfile: opts.ffiProfilePath === undefined || ffiProfileBytes === null
                 ? null
                 : { path: opts.ffiProfilePath, bytes: ffiProfileBytes },
@@ -1321,12 +1511,18 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             warningSink.warnings = earlyHit.performance;
             warningSink.sourceTexts = cachedWarningSources(earlyHit.performance);
         }
+        if (warningSink !== undefined && earlyHit.islands !== undefined)
+            warningSink.islands = earlyHit.islands;
         const executableCacheOptions = earlyCacheOptions;
         // 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) {
+            // The executable came back from the cache without a link, so the data
+            // files its Intl program loads at RUN time (ICU's icudt78l.dat) are not
+            // beside it yet; a cache hit that links gets them from the linker.
+            await installRuntimeDataBesideExecutable(earlyHit.native, opts.outPath);
             await pruneBuildCache(cacheRoot);
             timing("complete");
             return {
@@ -1401,6 +1597,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                         nativeDependencies: dependencies,
                         frontend: earlyHit.frontend,
                         ...profileMatchField(nativeProgramObject),
+                        ...partitionsField(nativeProgramObject),
                     });
                 }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, hitSources.llvmPath, nativeProfileLayout(profile), opts.hugeText !== false);
             if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
@@ -1415,11 +1612,13 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     sourceTexts: new Map(),
                 };
             }
-            if (ffi !== null && err instanceof CcCompileError) {
+            if (err instanceof CcCompileError) {
                 return {
                     ok: false,
                     diagnostics: [
-                        ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath),
+                        ffi !== null
+                            ? ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath)
+                            : nativeCodegenDiag("SC3004", err.message, entryPath),
                     ],
                     sourceTexts: new Map(),
                 };
@@ -1520,7 +1719,9 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     frontend: frontendInputs.snapshot(),
                     ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
                     ...performanceWarnings(warningSink),
+                    ...islandFields(warningSink),
                     ...profileMatchField(nativeProgramObject),
+                    ...partitionsField(nativeProgramObject),
                 });
                 publishedExecutable = true;
             }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, llvmPath, nativeProfileLayout(profile), opts.hugeText !== false);
@@ -1536,7 +1737,9 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                 frontend: frontendInputs.snapshot(),
                 ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
                 ...performanceWarnings(warningSink),
+                ...islandFields(warningSink),
                 ...profileMatchField(nativeProgramObject),
+                ...partitionsField(nativeProgramObject),
             }).catch(() => undefined);
         }
     }
@@ -1544,11 +1747,13 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
         if (err instanceof RuntimePackError) {
             return { ok: false, diagnostics: [runtimePackDiagnostic(err, entryPath)], sourceTexts };
         }
-        if (ffi !== null && err instanceof CcCompileError) {
+        if (err instanceof CcCompileError) {
             return {
                 ok: false,
                 diagnostics: [
-                    ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath),
+                    ffi !== null
+                        ? ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath)
+                        : nativeCodegenDiag("SC3004", err.message, entryPath),
                 ],
                 sourceTexts,
             };
@@ -1610,9 +1815,11 @@ function libraryNativeFeatures(mod, backend) {
         x509: features.x509,
         copying: features.copying,
         textDecoderLegacy: features.legacyTextDecoder,
+        bigintBytes: features.bigintBytes,
         dynInvoke: features.dynInvoke,
         ...(features.dynBuffer ? { dynBuffer: true } : {}),
         ...(features.dynTier ? { dynTier: true } : {}),
+        mutableBuffers: features.mutableBuffers,
         ...(mod.lib?.identity !== undefined ? { buildId: mod.lib.identity.buildId } : {}),
     };
 }
@@ -1686,9 +1893,11 @@ async function compileLibraryNative(profile, llvmPath, archivePath, sanitize, fe
         x509: features.x509,
         copying: features.copying,
         textDecoderLegacy: features.textDecoderLegacy,
+        bigintBytes: features.bigintBytes,
         dynInvoke: features.dynInvoke,
         ...(features.dynBuffer === true ? { dynBuffer: true } : {}),
         ...(features.dynTier === true ? { dynTier: true } : {}),
+        ...(features.mutableBuffers === true ? { mutableBuffers: true } : {}),
     };
     if (packTarget !== null)
         await compilePackedLibrary(archiveOptions, packTarget);