xbintsc 0.5.52 → 0.6.9

package/src/driver/runtime-objects.ts

@@ -12,7 +12,7 @@ import type { ExtensionRegistry } from "../extensions/registry.js";
 import type { ResolvedLinkFeature } from "./link-features.js";
 import { hashParts } from "./cache.js";
 import { findRuntimeLibrary } from "./runtime-lib.js";
-import { compileC, optimizationFlags, RUNTIME_CFLAGS, type PgoMode, type Runner } from "./toolchain.js";
+import { compileC, optimizationFlags, RUNTIME_CFLAGS, sysrootFlags, type PgoMode, type Runner } from "./toolchain.js";
 import { COMPILER_VERSION } from "./version.js";
 
 /** Core runtime translation units (each compiled and cached independently). */
@@ -51,6 +51,12 @@ export interface RuntimeObjects {
   readonly featureObjects: readonly string[];
   /** Pre-built C++/Rust objects and archives contributed by native extensions. */
   readonly nativeObjects: readonly string[];
+  /**
+   * The prebuilt `core`/`ext_<name>` archives this link used. Empty when the
+   * runtime was compiled from source. The driver retries a failed link without
+   * them, so it has to know whether the first attempt used any.
+   */
+  readonly prebuiltArchives: readonly string[];
 }
 
 export interface RuntimeObjectsOptions {
@@ -61,11 +67,16 @@ export interface RuntimeObjectsOptions {
   readonly registry: ExtensionRegistry;
   readonly preferPrebuilt: boolean;
   readonly env: Record<string, string>;
+  /** macOS SDK for `-isysroot`; part of the object cache key. */
+  readonly sdkRoot?: string;
   readonly lto: boolean;
   readonly pgo: PgoMode | undefined;
   readonly pgoDir: string;
   /** Optional link features selected for this program. */
   readonly features?: readonly ResolvedLinkFeature[];
+  /** Override the folders searched for prebuilt archives (defaults to the
+   * runtime's `lib/<os>-<arch>` plus the installed platform package). */
+  readonly runtimeLibDirs?: readonly string[];
 }
 
 /**
@@ -79,6 +90,9 @@ export interface RuntimeObjectsOptions {
 export function ensureRuntimeObjects(options: RuntimeObjectsOptions): RuntimeObjects {
   const { runner, clang, runtimeDir, cacheDir, registry, preferPrebuilt, env, lto, pgo, pgoDir } = options;
   const optimization = optimizationFlags(lto, pgo, pgoDir);
+  /* The sysroot joins the extra flags (and therefore the cache key): objects
+     compiled against a different SDK are a different artifact. */
+  const compileFlags = [...optimization, ...sysrootFlags(options.sdkRoot)];
   /* Runtime objects depend on the shared headers (rt.h/rt_internal.h/...) and
      the `#include`d implementation fragments (`.inc`), so any change to them
      must invalidate every cached object. Hash them all. */
@@ -99,7 +113,7 @@ export function ensureRuntimeObjects(options: RuntimeObjectsOptions): RuntimeObj
       "runtime",
       COMPILER_VERSION,
       RUNTIME_CFLAGS.join(" "),
-      optimization.join(" "),
+      compileFlags.join(" "),
       tag,
       headerStamp,
       body,
@@ -108,24 +122,30 @@ export function ensureRuntimeObjects(options: RuntimeObjectsOptions): RuntimeObj
     ]);
     const objectPath = join(cacheDir, `${tag}-${key}.o`);
     if (!existsSync(objectPath)) {
-      compileC(runner, clang, sourcePath, objectPath, runtimeDir, env, optimization);
+      compileC(runner, clang, sourcePath, objectPath, runtimeDir, env, compileFlags);
     }
     return objectPath;
   };
 
-  const coreArchive = preferPrebuilt ? findRuntimeLibrary("core") : undefined;
+  const coreArchive = preferPrebuilt ? findRuntimeLibrary("core", options.runtimeLibDirs) : undefined;
   const runtimeObjects = coreArchive
     ? [coreArchive]
     : RUNTIME_SOURCES.map((source) => compileOne(join(runtimeDir, source), basename(source, ".c")));
 
+  /** Prebuilt archives this link uses; the driver retries without them. */
+  const prebuiltArchives: string[] = coreArchive ? [coreArchive] : [];
+
   const extensionObjects: string[] = [];
   const seen = new Set<string>();
   for (const extension of registry.all()) {
     const sources = extension.runtimeSources ? extension.runtimeSources() : [];
     if (sources.length === 0) continue;
-    const archive = preferPrebuilt ? findRuntimeLibrary(`ext_${extension.name}`) : undefined;
+    const archive = preferPrebuilt
+      ? findRuntimeLibrary(`ext_${extension.name}`, options.runtimeLibDirs)
+      : undefined;
     if (archive) {
       extensionObjects.push(archive);
+      prebuiltArchives.push(archive);
       continue;
     }
     for (const sourcePath of sources) {
@@ -156,5 +176,6 @@ export function ensureRuntimeObjects(options: RuntimeObjectsOptions): RuntimeObj
     extensionObjects,
     featureObjects: [...new Set(featureObjects)],
     nativeObjects: [...new Set(registry.nativeObjects())],
+    prebuiltArchives,
   };
 }

package/src/driver/toolchain-provider.ts

@@ -22,11 +22,17 @@
  * skipped (or rejected, when named explicitly) instead of producing objects
  * the linker cannot mix.
  *
+ * On macOS the resolved driver also carries the SDK as `sdkRoot`, which the
+ * compile and link steps pass as `-isysroot` (see `macos-sdk.ts`): an Apple
+ * clang invoked by absolute path does not infer the SDK by itself, and without
+ * one not even `<stdio.h>` — nor the linker's `libm` stub — is found.
+ *
  * Extra linker arguments (for example `-fuse-ld=lld`) can be supplied through
  * `xbintsc_LINKER_ARGS`.
  */
 
 import { locateClang, realRunner, type ClangVersion, type Runner } from "./toolchain.js";
+import { macosSdkRoot } from "./macos-sdk.js";
 
 export type ToolchainSource = "env" | "system";
 
@@ -42,6 +48,9 @@ export interface ResolvedToolchain {
   /** Extra environment for the toolchain subprocesses, merged over the current
    * environment. */
   readonly env: Record<string, string>;
+  /** macOS SDK to pass as `-isysroot`; lost off macOS or when `SDKROOT` is
+   * already set. See `macos-sdk.ts`. */
+  readonly sdkRoot?: string;
 }
 
 function linkerArgs(fallback: readonly string[]): string[] {
@@ -53,11 +62,13 @@ function linkerArgs(fallback: readonly string[]): string[] {
 /** Resolve the toolchain that `build` should use. See the module docblock. */
 export function resolveToolchain(runner: Runner = realRunner): ResolvedToolchain {
   const location = locateClang(runner);
+  const sdkRoot = macosSdkRoot(runner);
   return {
     clang: location.command,
     source: location.source,
     ...(location.version ? { version: location.version } : {}),
     linkerArgs: linkerArgs([]),
     env: {},
+    ...(sdkRoot === undefined ? {} : { sdkRoot }),
   };
 }

package/src/driver/toolchain.ts

@@ -144,6 +144,75 @@ export function probeClang(
   }
 }
 
+/**
+ * Release years that name their install directory after the year, mapped to the
+ * major version each release actually ships (VS 2022 is version 17).
+ */
+const VISUAL_STUDIO_YEAR_MAJOR: Readonly<Record<string, number>> = {
+  "2015": 14,
+  "2017": 15,
+  "2019": 16,
+  "2022": 17,
+};
+
+/**
+ * Sort key for a directory under `%ProgramFiles%\Microsoft Visual Studio`.
+ * Releases up to 2022 use year names ("2022"); Visual Studio 2026 (version 18)
+ * and later use the plain major version ("18").
+ */
+function visualStudioMajor(directoryName: string): number {
+  const known = VISUAL_STUDIO_YEAR_MAJOR[directoryName];
+  if (known !== undefined) return known;
+  return /^\d+$/.test(directoryName) ? Number(directoryName) : -1;
+}
+
+/** Immediate subdirectory names, or `[]` when the directory cannot be read. */
+function subdirectories(directory: string): string[] {
+  try {
+    return readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Preference order when one release has several installs; channel names not
+ * listed here (for example `Insiders`) follow alphabetically.
+ */
+const VISUAL_STUDIO_EDITIONS: readonly string[] = ["Community", "Professional", "Enterprise", "BuildTools"];
+
+function editionRank(edition: string): number {
+  const index = VISUAL_STUDIO_EDITIONS.indexOf(edition);
+  return index === -1 ? VISUAL_STUDIO_EDITIONS.length : index;
+}
+
+/**
+ * The `VC\Tools\Llvm` directory of every Visual Studio installation under one
+ * `Microsoft Visual Studio` root, newest release first.
+ *
+ * Both layouts are discovered by enumerating directories — `<year>\<edition>`
+ * for 2019/2022 (for example `2022\BuildTools`) and `<major>\<channel>` for
+ * Visual Studio 2026 and later (for example `18\Insiders`) — so a future
+ * release needs no code change and a non-default channel still works.
+ */
+export function visualStudioLlvmDirs(visualStudioRoot: string): string[] {
+  const versions = subdirectories(visualStudioRoot)
+    .filter((name) => visualStudioMajor(name) >= 0)
+    .sort((a, b) => visualStudioMajor(b) - visualStudioMajor(a));
+  const dirs: string[] = [];
+  for (const version of versions) {
+    const editions = subdirectories(join(visualStudioRoot, version)).sort(
+      (a, b) => editionRank(a) - editionRank(b) || a.localeCompare(b),
+    );
+    for (const edition of editions) {
+      dirs.push(join(visualStudioRoot, version, edition, "VC", "Tools", "Llvm"));
+    }
+  }
+  return dirs;
+}
+
 /**
  * Visual Studio ships its own LLVM build (`VC\Tools\Llvm\x64\bin\clang.exe`).
  * It is a perfectly good driver but is not on `PATH` in a plain shell, so probe
@@ -152,17 +221,19 @@ export function probeClang(
  */
 function visualStudioClangCandidates(): string[] {
   if (process.platform !== "win32") return [];
-  const roots = [process.env.ProgramFiles, process.env["ProgramFiles(x86)"], process.env.ProgramW6432]
-    .filter((root): root is string => Boolean(root));
+  const roots = [
+    ...new Set(
+      [process.env.ProgramFiles, process.env["ProgramFiles(x86)"], process.env.ProgramW6432].filter(
+        (root): root is string => Boolean(root),
+      ),
+    ),
+  ];
   const arch = process.arch === "arm64" ? "ARM64" : "x64";
   const candidates: string[] = [];
   for (const root of roots) {
-    for (const year of ["2022", "2019"]) {
-      for (const edition of ["Community", "Professional", "Enterprise", "BuildTools"]) {
-        const llvm = join(root, "Microsoft Visual Studio", year, edition, "VC", "Tools", "Llvm");
-        candidates.push(join(llvm, arch, "bin", "clang.exe"));
-        candidates.push(join(llvm, "bin", "clang.exe"));
-      }
+    for (const llvm of visualStudioLlvmDirs(join(root, "Microsoft Visual Studio"))) {
+      candidates.push(join(llvm, arch, "bin", "clang.exe"));
+      candidates.push(join(llvm, "bin", "clang.exe"));
     }
     candidates.push(join(root, "LLVM", "bin", "clang.exe"));
   }
@@ -299,12 +370,25 @@ export function optimizationFlags(
   return flags;
 }
 
+/**
+ * `-isysroot` for a resolved macOS SDK, or nothing off macOS.
+ *
+ * The sysroot travels on the command line and not as `SDKROOT` in the
+ * environment because the self-hosted compiler's `spawnSync` ignores
+ * `options.env`; flags survive that. See `macos-sdk.ts`.
+ */
+export function sysrootFlags(sdkRoot: string | undefined): string[] {
+  return sdkRoot === undefined ? [] : ["-isysroot", sdkRoot];
+}
+
 export interface CompileIrOptions {
   readonly clang: string;
   readonly irPath: string;
   readonly objectPath: string;
   readonly optimize: string;
   readonly env?: Record<string, string>;
+  /** macOS SDK for `-isysroot`; see {@link sysrootFlags}. */
+  readonly sdkRoot?: string;
   /** Emit debug info (`-g`) and keep frame pointers for crash backtraces. */
   readonly debug?: boolean;
   /** Compile to LTO bitcode and let the linker optimize across units. */
@@ -332,6 +416,7 @@ export function compileIr(runner: Runner, options: CompileIrOptions): void {
       ...SECTION_FLAGS,
       ...debugFlags,
       ...profileFlags,
+      ...sysrootFlags(options.sdkRoot),
       "-c",
       options.irPath,
       "-o",
@@ -349,6 +434,9 @@ export interface LinkOptions {
   readonly linkerFlags: readonly string[];
   readonly optimize: string;
   readonly env?: Record<string, string>;
+  /** macOS SDK for `-isysroot`; the linker's stubs (`libm`, `libSystem`) come
+   * from it, so a link without one fails with `library 'm' not found`. */
+  readonly sdkRoot?: string;
   readonly lto?: boolean;
   readonly pgo?: PgoMode;
   readonly pgoDir?: string;
@@ -361,7 +449,13 @@ function deadStripFlag(): string[] {
   return ["-Wl,--gc-sections"];
 }
 
-export function link(runner: Runner, options: LinkOptions): void {
+/**
+ * Link the program and return the command result. A successful link can still
+ * carry a warning (for example ld64's "object file was built for newer macOS
+ * version"); the driver inspects `stderr` to decide whether a prebuilt archive
+ * should be rebuilt from source.
+ */
+export function link(runner: Runner, options: LinkOptions): CommandResult {
   const profileFlags = optimizationFlags(options.lto, options.pgo, options.pgoDir);
   const args = [
     `-O${options.optimize}`,
@@ -370,6 +464,7 @@ export function link(runner: Runner, options: LinkOptions): void {
      * understands both ELF/Mach-O and COFF; without it MSVC link.exe rejects
      * the bitcode object on Windows. */
     ...(options.lto ? ["-fuse-ld=lld"] : []),
+    ...sysrootFlags(options.sdkRoot),
     ...options.objectPaths,
     "-o",
     options.outputPath,
@@ -378,6 +473,7 @@ export function link(runner: Runner, options: LinkOptions): void {
   ];
   const result = runner.run(options.clang, args, { env: options.env });
   if (result.status !== 0) throw new ToolchainError(`${options.clang} link`, result.status, result.stderr);
+  return result;
 }
 
 /**

package/src/driver/version.ts

@@ -9,4 +9,4 @@
  * `main`/`master` only (see `.githooks/pre-commit`), so feature branches never
  * change this line and merging two of them cannot conflict here.
  */
-export const COMPILER_VERSION = "0.5.52";
+export const COMPILER_VERSION = "0.6.9";

package/src/driver/win-entry.ts

@@ -15,7 +15,7 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { hashParts } from "./cache.js";
-import { compileC, type Runner } from "./toolchain.js";
+import { compileC, sysrootFlags, type Runner } from "./toolchain.js";
 
 /** The bridge source. `main` is the entry point the runtime emits. */
 export const WINDOWS_ENTRY_SOURCE = `/* Generated by xbintsc - Windows GUI subsystem entry point. Do not edit. */
@@ -46,14 +46,15 @@ export function ensureWindowsEntryObject(
   clang: string,
   cacheDir: string,
   env?: Record<string, string>,
+  sdkRoot?: string,
 ): string {
-  const key = hashParts(["win-gui-entry", process.platform, clang, WINDOWS_ENTRY_SOURCE]);
+  const key = hashParts(["win-gui-entry", process.platform, clang, sdkRoot ?? "", WINDOWS_ENTRY_SOURCE]);
   const sourcePath = join(cacheDir, `winentry-${key}.c`);
   const objectPath = join(cacheDir, `winentry-${key}.o`);
   if (!existsSync(objectPath)) {
     mkdirSync(cacheDir, { recursive: true });
     writeFileSync(sourcePath, WINDOWS_ENTRY_SOURCE);
-    compileC(runner, clang, sourcePath, objectPath, cacheDir, env);
+    compileC(runner, clang, sourcePath, objectPath, cacheDir, env, sysrootFlags(sdkRoot));
   }
   return objectPath;
 }

package/src/extensions/gui/html.ts

@@ -12,13 +12,16 @@
  * This is how xbintsc supports `<script>` without a JavaScript engine: the body
  * is ordinary TypeScript compiled by the existing front end, ahead of time.
  *
- * Inline `<script lang="ts">body</script>` bodies are wrapped directly. External
- * `<script src="./app.ts">` files are read, their top-level `import`/`export
- * … from` statements are hoisted to the generated module (with relative
- * specifiers rewritten so they resolve from the HTML file), and the remaining
- * statements are wrapped in the script function. All scripts run in document
- * order after parsing (there is no "eager" execution point), i.e. every script
- * is effectively `defer`red.
+ * Both forms are compiled the same way: an inline
+ * `<script lang="ts">body</script>` body and an external `<script src="./app.ts">`
+ * file are parsed as a module, their top-level `import`/`export … from`
+ * statements are hoisted to the generated module (with relative specifiers
+ * rewritten so they resolve from the HTML file), and the remaining statements
+ * are wrapped in the script function. An inline body therefore resolves imports
+ * relative to the page that contains it, exactly like `<script type="module">`
+ * in a browser — including a `node:`/bare specifier, which links like any other
+ * module import. All scripts run in document order after parsing (there is no
+ * "eager" execution point), i.e. every script is effectively `defer`red.
  */
 
 import { existsSync, readFileSync } from "node:fs";
@@ -161,12 +164,18 @@ function deferredPrelude(alias: string, declaration: ImportDeclaration): string[
   return lines;
 }
 
-/** Split an external script module into hoisted imports and a body. */
-function compileModuleSource(htmlPath: string, scriptPath: string, scriptIndex: number): CompiledModule {
+/** Split a script module into hoisted imports and a body. */
+function compileModuleSource(
+  htmlPath: string,
+  scriptPath: string,
+  scriptSource: string,
+  scriptIndex: number,
+): CompiledModule {
   /* Mask the normalized text: the parser indexes the `SourceFile` text, where
    * `\r\n` already became `\n`, so blanking statement spans in the raw file
-   * would remove the wrong characters on a CRLF checkout. */
-  const source = new SourceFile(scriptPath, readFileSync(scriptPath, "utf8")).text;
+   * would remove the wrong characters on a CRLF checkout. An inline body is
+   * already normalized (the page was), so this is the identity for it. */
+  const source = new SourceFile(scriptPath, scriptSource).text;
   const bag = new DiagnosticBag();
   const parsed = new Parser(new SourceFile(scriptPath, source), bag).parseSourceFile();
   const chars = source.split("");
@@ -272,6 +281,35 @@ export function loadHtmlAsset(path: string, source: string): AssetLoadResult {
   const importedText = new Set<string>();
   const bound = new Set<string>();
 
+  /* Every script's hoisted imports live at module scope, so they are collected
+   * here and placed in front of the script functions. `element` and `hint` only
+   * shape the error for an eager binding claimed by two scripts. */
+  const hoistImports = (compiled: CompiledModule, element: string, hint: string): void => {
+    for (const text of compiled.imports) {
+      if (!importedText.has(text)) {
+        importedText.add(text);
+        imports.push(text);
+      }
+    }
+    lazyImports.push(...compiled.lazyImports);
+    for (const name of compiled.localNames) {
+      if (bound.has(name)) {
+        throw new Error(
+          `gui: ${element} imports '${name}', already imported by another <script>; ${hint}`,
+        );
+      }
+      bound.add(name);
+    }
+  };
+  const register = (compiled: CompiledModule, file?: string): string => {
+    /* Hash the wrapped body, prelude included: the engine keys the registry by
+     * id, so two scripts with the same statements but different deferred
+     * imports must not collapse into one entry. */
+    const id = hashString([...compiled.prelude, compiled.body].join("\n"));
+    scripts.push({ id, body: compiled.body, prelude: compiled.prelude, ...(file ? { file } : {}) });
+    return id;
+  };
+
   /* The engine's cascade only reads `<style>` elements, so a linked stylesheet
    * would be dropped at runtime. Inline it (and its `@import`s) now. */
   const styles = inlineStylesheets(path, page);
@@ -284,32 +322,24 @@ export function loadHtmlAsset(path: string, source: string): AssetLoadResult {
       if (!existsSync(scriptPath)) {
         throw new Error(`gui: <script src="${src}"> not found (looked for ${scriptPath})`);
       }
-      const compiled = compileModuleSource(path, scriptPath, scripts.length);
-      for (const text of compiled.imports) {
-        if (!importedText.has(text)) {
-          importedText.add(text);
-          imports.push(text);
-        }
-      }
-      lazyImports.push(...compiled.lazyImports);
-      for (const name of compiled.localNames) {
-        if (bound.has(name)) {
-          throw new Error(
-            `gui: <script src="${src}"> imports '${name}', already imported by another <script src>; alias it in ${scriptPath}`,
-          );
-        }
-        bound.add(name);
-      }
-      const id = hashString([...compiled.prelude, compiled.body].join("\n"));
-      scripts.push({ id, body: compiled.body, prelude: compiled.prelude, file: scriptPath });
+      const compiled = compileModuleSource(path, scriptPath, readFileSync(scriptPath, "utf8"), scripts.length);
+      hoistImports(compiled, `<script src="${src}">`, `alias it in ${scriptPath}`);
+      const id = register(compiled, scriptPath);
       return `<script data-xt-id="${id}"></script>`;
     }
 
     /* A `src` URL, or a data block: leave the element untouched. */
     if (src !== undefined) return match;
     if (inlineBody.trim() === "") return match;
-    const id = hashString(inlineBody);
-    scripts.push({ id, body: inlineBody, prelude: [] });
+    /* An inline body is compiled exactly like a `<script src>` file, so an
+     * `import` links the same way in both: a bare or `node:` specifier is
+     * hoisted to the generated module, a relative one is deferred, and both
+     * resolve from the HTML file as a browser module script would. Wrapping the
+     * body verbatim used to leave an inline `import` inside the script function,
+     * where codegen cannot link its binding (TS5001). */
+    const compiled = compileModuleSource(path, path, inlineBody, scripts.length);
+    hoistImports(compiled, "inline <script>", "alias it");
+    const id = register(compiled);
     return `<script data-xt-id="${id}"></script>`;
   });
 

package/src/extensions/node/child_process/index.ts

@@ -1,9 +1,10 @@
 /**
  * Node's `child_process` module: `spawnSync(command, args, options)`, backed by
  * `runtime/ext_node/child_process`. Captures stdout/stderr as UTF-8 strings,
- * honours `options.cwd`, and supports `options.stdio: "inherit"` (hand the
- * child the parent's stdout/stderr) — which is all the compiler's toolchain
- * wrapper and `xbintsc run` need.
+ * honours `options.cwd` and `options.env` (replace semantics, like Node), and
+ * supports `options.stdio: "inherit"` (hand the child the parent's
+ * stdout/stderr) — which is all the compiler's toolchain wrapper and
+ * `xbintsc run` need.
  */
 
 import type { NodeModule } from "../module.js";