xbintsc 0.5.52 → 0.6.8

package/src/driver/toolchain.ts

@@ -299,12 +299,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 +345,7 @@ export function compileIr(runner: Runner, options: CompileIrOptions): void {
       ...SECTION_FLAGS,
       ...debugFlags,
       ...profileFlags,
+      ...sysrootFlags(options.sdkRoot),
       "-c",
       options.irPath,
       "-o",
@@ -349,6 +363,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 +378,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 +393,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 +402,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.8";

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";