@scriptc/compiler 0.0.25 → 0.0.27

package/ambient/scriptc-node-fallback.d.ts

@@ -2118,25 +2118,33 @@ declare module "node:net" {
  * connection per call (no agent pooling) with Node's exact wire head. */
 declare module "http" {
   import { Server as NetServer, Socket } from "net";
-  export type Server = NetServer;
+  export interface Server extends NetServer {
+    timeout: number;
+    keepAliveTimeout: number;
+    keepAliveTimeoutBuffer: number;
+    headersTimeout: number;
+    requestTimeout: number;
+  }
   export type RequestListener =
     (req: IncomingMessage, res: ServerResponse) => void;
   /* The Server VALUE — Node's constructor works with and without `new`
    * (test/parallel's http.Server(fn) spelling); both route to the
    * createServer lowering. */
   export const Server: {
-    new (requestListener?: (req: IncomingMessage, res: ServerResponse) => void): NetServer;
-    new (options: ServerOptions, requestListener?: (req: IncomingMessage, res: ServerResponse) => void): NetServer;
-    (requestListener?: (req: IncomingMessage, res: ServerResponse) => void): NetServer;
-    (options: ServerOptions, requestListener?: (req: IncomingMessage, res: ServerResponse) => void): NetServer;
+    new (requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
+    new (options: ServerOptions, requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
+    (requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
+    (options: ServerOptions, requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
   };
   /* The options-record stance (the RequestOptions precedent): every
    * documented key typechecks; the lowering's option walk decides per
-   * key — requireHostHeader: false and joinDuplicateHeaders lower,
+   * key — requireHostHeader: false, joinDuplicateHeaders, and
+   * keepAliveTimeoutBuffer lower,
    * documented-but-unlowered keys fence by name, unknown keys drop. */
   export interface ServerOptions {
     requireHostHeader?: boolean;
     joinDuplicateHeaders?: boolean;
+    keepAliveTimeoutBuffer?: number;
     [option: string]: unknown;
   }
   /* The outgoing-header shape, @types/node's matrix: numbers format via
@@ -2392,7 +2400,7 @@ declare module "node:tls" {
  * self-signed probe shape). With neither, /etc/ssl/cert.pem stands in
  * for Node's bundled roots. */
 declare module "https" {
-  import { Server } from "net";
+  import { Server } from "http";
   import { Agent, ClientRequest, IncomingMessage, ServerResponse } from "http";
   export { Agent, Server };
   export interface ServerOptions {

package/dist/backend/cc.d.ts

@@ -214,6 +214,9 @@ export interface CcDriver {
     linkArgs: string[];
 }
 export declare function resolveCc(env?: NodeJS.ProcessEnv, hostPlatform?: NodeJS.Platform): CcDriver;
+/** Musl intentionally has no predefined libc macro. The explicit Zig target
+ * is therefore the source of truth for selecting its small runtime shim. */
+export declare function isMuslTarget(driver: Pick<CcDriver, "target">): boolean;
 /** The OS the produced binary runs on: the triple's OS under SCRIPTC_TARGET,
  * the host's otherwise — so platform-conditional link flags follow the
  * TARGET, not the machine running the compiler. Exported for compile()/
@@ -245,6 +248,25 @@ export interface LibArchiveOptions {
      * matching compileC's arbitrary-input safety boundary. */
     cacheIdentity?: string;
     sanitize?: boolean;
+    /** Multi-instance library mode (the profile's abi.localize_runtime): the
+     * external symbols to KEEP global — every other scriptc external
+     * definition in the archive (the runtime's internals, the program TU's
+     * mangled functions and globals, vendor objects) is demoted to a local
+     * symbol. Toolchain sanitizer ABI remains external as required,
+     * so N archives built under pairwise-distinct prefixes link into one
+     * process with no symbol collisions and no shared mutable runtime state.
+     * Undefined references (libc/libm, plus sanitizer ABI in instrumented
+     * builds) keep their global binding. Omitted = the classic archive,
+     * byte-for-byte. Host-native builds only. */
+    localizeSymbols?: readonly string[];
+    /** Thread-instanced state (the profile's abi.instance_per_thread): every
+     * TU of the archive compiles with -DSCR_THREAD_INSTANCES, moving the
+     * runtime units' mutable statics into thread-local storage (SCR_TL in
+     * scr_runtime.h) to match the program TU's thread-local globals — one
+     * complete instance per embedder thread. The define rides cflags, so
+     * every cache tier keys it automatically; omitted = the classic
+     * archive, byte-for-byte. */
+    threadInstances?: boolean;
     /** IR-detected link gates (the compileC precedent, refusal-narrowed). */
     regex?: boolean;
     assert?: boolean;

package/dist/backend/cc.js

@@ -197,14 +197,34 @@ export function resolveCc(env = process.env, hostPlatform = process.platform) {
     }
     if (target === "")
         return { argv: ["zig", "cc"], target: null, ...hostArgs };
+    if (target.includes("wasi") && target !== "wasm32-wasi") {
+        throw new Error(`unsupported WASI target '${target}' (supported: wasm32-wasi)`);
+    }
     const linux = target.includes("linux");
+    const wasi = target.includes("wasi");
+    const musl = target.includes("linux-musl");
     return {
         argv: ["zig", "cc"],
         target,
-        targetArgs: ["-target", target, ...(linux ? ["-D_GNU_SOURCE"] : [])],
-        linkArgs: linux ? ["-lm"] : [],
+        targetArgs: [
+            "-target",
+            target,
+            ...(linux || wasi ? ["-D_GNU_SOURCE"] : []),
+            ...(musl ? ["-DSCR_MUSL"] : []),
+            ...(wasi ? ["-D_WASI_EMULATED_SIGNAL", "-D_WASI_EMULATED_PROCESS_CLOCKS"] : []),
+        ],
+        linkArgs: linux
+            ? ["-lm"]
+            : wasi
+                ? ["-lwasi-emulated-signal", "-lwasi-emulated-process-clocks"]
+                : [],
     };
 }
+/** Musl intentionally has no predefined libc macro. The explicit Zig target
+ * is therefore the source of truth for selecting its small runtime shim. */
+export function isMuslTarget(driver) {
+    return driver.target?.includes("linux-musl") ?? false;
+}
 /** The OS the produced binary runs on: the triple's OS under SCRIPTC_TARGET,
  * the host's otherwise — so platform-conditional link flags follow the
  * TARGET, not the machine running the compiler. Exported for compile()/
@@ -214,6 +234,8 @@ export function resolveCc(env = process.env, hostPlatform = process.platform) {
 export function targetPlatform(driver) {
     if (driver.target === null)
         return process.platform;
+    if (driver.target.includes("wasi"))
+        return "wasi";
     if (driver.target.includes("linux"))
         return "linux";
     if (driver.target.includes("windows"))
@@ -715,6 +737,9 @@ export async function compileLibArchive(opts) {
         // carries no -l flags. Never present off win32, so host archives
         // cannot change by a byte.
         ...(targetPlatform(driver) === "win32" ? ["scr_win.c"] : []),
+        // Zig's musl sysroot does not provide arc4random_buf. Keep the fallback
+        // inside the archive so library embedders need no extra system library.
+        ...(isMuslTarget(driver) ? ["scr_musl.c"] : []),
         ...(regex ? ["scr_regex.c"] : []),
         ...(opts.assert || regex || opts.symbol ? ["scr_assert.c"] : []),
         ...(opts.inspect ? ["scr_inspect.c"] : []),
@@ -732,6 +757,7 @@ export async function compileLibArchive(opts) {
         "-fno-strict-aliasing", // the emitted object model type-puns — see compileC's buildArgs
         "-Wno-deprecated-declarations",
         "-DSCR_LIB",
+        ...(opts.threadInstances ? ["-DSCR_THREAD_INSTANCES"] : []),
         ...(opts.textDecoderLegacy ? ["-DSCR_TEXT_DECODER_LEGACY"] : []),
         "-I", rtDir,
         ...(regex ? ["-I", vendorEngineDir()] : []),
@@ -790,7 +816,12 @@ export async function compileLibArchive(opts) {
         }
     }
     const vendorBuildIdentity = await currentVendorCacheBuildIdentity(driver, `${toolchainEnv}\0${implicitToolchain ?? "<uncached>"}`);
-    const cacheCompleteArchive = root !== null && await archiverSupportsPersistentCache(arArgv, driver);
+    // Runtime-localized archives skip the completed-archive tier: their bytes
+    // additionally depend on the host's ld/objcopy identities, which the
+    // archive key does not fingerprint. The runtime-object tier still serves
+    // them (localization consumes the same per-flavor objects).
+    const cacheCompleteArchive = opts.localizeSymbols === undefined &&
+        root !== null && await archiverSupportsPersistentCache(arArgv, driver);
     let cachedArchive = null;
     let compilerVersion = "";
     let archiverVersion = "";
@@ -943,17 +974,29 @@ export async function compileLibArchive(opts) {
                 }
             }
             const objects = [programObject, ...runtimeObjects, ...lreObjects, ...zlibObjects];
-            // A cacheable build owns a private archive from `ar` through publication.
-            // The caller-visible output can be shared by another invocation without
-            // letting that invocation's bytes poison this key.
-            const archiveOutput = cachedArchive === null ? opts.outPath : join(buildDir, "artifact.lib.a");
+            // Multi-instance library mode: the archive's one member becomes the
+            // combined, symbol-localized object (cached vendor/runtime objects
+            // are read-only inputs here — the combine step never mutates them).
+            const archiveMembers = opts.localizeSymbols === undefined
+                ? objects
+                : [
+                    await localizeLibraryObjects(driver, arArgv, buildDir, programObject, [...runtimeObjects, ...lreObjects, ...zlibObjects], opts.localizeSymbols, stem),
+                ];
+            // A cacheable or runtime-localized build owns a private archive from
+            // `ar` through publication. Localized archives deliberately bypass the
+            // completed-artifact cache, but still need atomic installation so two
+            // invocations sharing a caller-visible output cannot race `rm`/`ar` on
+            // that path.
+            const archiveOutput = cachedArchive === null && opts.localizeSymbols === undefined
+                ? opts.outPath
+                : join(buildDir, "artifact.lib.a");
             await rm(archiveOutput, { force: true }); // `ar r` would append into a stale archive
             await mkdir(dirname(archiveOutput), { recursive: true });
             await execFileAsync(arArgv[0] ?? "ar", [
                 ...arArgv.slice(1),
                 "rcs",
                 archiveOutput,
-                ...objects,
+                ...archiveMembers,
             ]);
             if (archiveOutput !== opts.outPath)
                 await installArtifact(archiveOutput, opts.outPath);
@@ -1004,6 +1047,73 @@ export async function compileLibArchive(opts) {
     if (root !== null)
         await pruneCache(root).catch(() => undefined);
 }
+/* Multi-instance library mode's localization step: combine the program
+ * object with exactly the runtime/vendor members it reaches into ONE
+ * relocatable object, then demote every scriptc external definition except
+ * the profile-declared symbols to a local symbol. The internals are not
+ * renamed apart — they stop being visible to the embedder's linker at all,
+ * so a second archive built under a different prefix brings its own private
+ * copy of the whole runtime (allocator, collector, arena, panic sink) into
+ * the same process. Undefined references (libc/libm, plus sanitizer ABI in
+ * instrumented builds) keep their global binding: the C library and
+ * sanitizer are the embedder's, shared by design.
+ *
+ * Member selection matters: a classic archive's unused members (and their
+ * undefined references to units library mode excludes, like the
+ * fs-promises unit's fiber symbols) never reach an embedder's link. A
+ * blind merge of every object would carry those references into the one
+ * combined member. Staging the support objects into an intermediate
+ * archive keeps the linker's own member semantics: `ld -r` pulls only the
+ * members the program object transitively needs.
+ *
+ *   darwin — one ld64 invocation: -r merges program + needed members,
+ *            -exported_symbols_list demotes every unlisted global to
+ *            private extern, and -r without -keep_private_externs writes
+ *            private externs out as non-external symbols. Apple ASan's
+ *            image-registration COMMON remains shared so the final Mach-O
+ *            image registers its globals once.
+ *   linux  — ld -r merges with --force-group-allocation (ASan's
+ *            instrumented globals ride ELF section groups whose signatures
+ *            repeat across archives sharing runtime objects; resolving the
+ *            groups into the combined member keeps a later multi-archive
+ *            link from discarding one archive's copies), then binutils
+ *            objcopy --keep-global-symbols localizes every other DEFINED
+ *            global (objcopy leaves undefined symbols global by its own
+ *            rule).
+ *
+ * Host-native only: compileLibrary refuses localization for cross targets
+ * before emission (this step runs the host's ld/objcopy over host-format
+ * objects). */
+async function localizeLibraryObjects(driver, arArgv, buildDir, programObject, supportObjects, keepSymbols, stem) {
+    const platform = targetPlatform(driver);
+    const combined = join(buildDir, `${stem}.localized.o`);
+    const staging = join(buildDir, `${stem}.localize-staging.a`);
+    const keepFile = join(buildDir, "localize-keep.syms");
+    const run = async (argv) => {
+        try {
+            await execFileAsync(argv[0], [...argv.slice(1)]);
+        }
+        catch (err) {
+            const stderr = err.stderr ?? String(err);
+            throw new Error(`${argv[0]} failed while localizing the library archive's runtime symbols (abi.localize_runtime).\n` +
+                `Runtime symbol localization needs the host toolchain's ${platform === "darwin" ? "ld" : "ld and objcopy"} beside the C compiler.\n\n${stderr}`);
+        }
+    };
+    await run([arArgv[0] ?? "ar", ...arArgv.slice(1), "rcs", staging, ...supportObjects]);
+    if (platform === "darwin") {
+        await writeFile(keepFile, keepSymbols.map((s) => `_${s}\n`).join(""));
+        await run(["ld", "-r", programObject, staging, "-o", combined, "-exported_symbols_list", keepFile]);
+    }
+    else if (platform === "linux") {
+        await writeFile(keepFile, keepSymbols.map((s) => `${s}\n`).join(""));
+        await run(["ld", "-r", "--force-group-allocation", programObject, staging, "-o", combined]);
+        await run(["objcopy", `--keep-global-symbols=${keepFile}`, combined]);
+    }
+    else {
+        throw new Error(`runtime symbol localization (abi.localize_runtime) supports darwin and linux host builds; this build targets ${platform}`);
+    }
+    return combined;
+}
 /* -------------------------- persistent build cache ---------------------------
  * Content-addressed caches that let repeat builds of unchanged programs skip
  * payload code generation/linking — the test lanes' dominant cost. Executable
@@ -2167,9 +2277,14 @@ export async function compileC(opts) {
     const http = (opts.http ?? false) || nativeFetch || netIsland;
     const tls = (opts.tls ?? false) || nativeFetch || netIsland;
     const driver = resolveCc();
+    const runtimeSources = targetPlatform(driver) === "wasi"
+        ? RUNTIME_SOURCES.filter((source) => source !== "scr_child.c")
+        : RUNTIME_SOURCES;
     // scr_async.c submits callback-style filesystem work to a native worker.
     // POSIX drivers need the thread compile/link mode; win32 uses CreateThread.
-    const threadArgs = targetPlatform(driver) === "win32" ? [] : ["-pthread"];
+    const threadArgs = targetPlatform(driver) === "win32" || targetPlatform(driver) === "wasi"
+        ? []
+        : ["-pthread"];
     if (driver.target !== null) {
         // See the resolveCc block: these inputs are built on and for the HOST
         // (vendored archives, system libs). Regex, zlib, and the engine archive
@@ -2314,7 +2429,7 @@ export async function compileC(opts) {
         "-fno-strict-aliasing",
         "-Wno-deprecated-declarations", // ucontext fibers (scr_async.c)
         "-I", rtDir,
-        ...RUNTIME_SOURCES.map((f) => rt(join(rtDir, f))),
+        ...runtimeSources.map((f) => rt(join(rtDir, f))),
         ...(opts.copying ? [rt(join(rtDir, "scr_copying.c"))] : []),
         ...(opts.fileHandle ? [rt(join(rtDir, "scr_file_handle.c"))] : []),
         // win32 targets compile the libc-shim TU (stpcpy, arc4random_buf,
@@ -2327,6 +2442,9 @@ export async function compileC(opts) {
         ...(targetPlatform(driver) === "win32"
             ? [rt(join(rtDir, "scr_win.c")), "-ladvapi32", "-liphlpapi", "-lws2_32"]
             : []),
+        // musl deliberately has no libc-identification predefine; resolveCc's
+        // SCR_MUSL flag and this target-selected TU travel together.
+        ...(isMuslTarget(driver) ? [rt(join(rtDir, "scr_musl.c"))] : []),
         ...(regex
             ? ["-I", vendorEngineDir(), rt(join(rtDir, "scr_regex.c")), ...lreObjects]
             : []),