xbintsc 0.5.31 → 0.5.32

package/src/codegen/generator/module.ts

@@ -9,6 +9,7 @@ import {
   type ArrowFunction,
   type Block,
   type Expression,
+  type FunctionDeclaration,
   type Parameter,
 } from "../../ast/nodes.js";
 import type { ClassInfo, FunctionInfo, SymbolInfo } from "../../binder/binder.js";
@@ -39,6 +40,7 @@ function symbolSuffix(name: string): string {
 export interface ModuleMethods {
   run(this: Generator): string;
   emitFunction(this: Generator, fn: FunctionInfo): void;
+  emitHoistedFunctions(this: Generator, fn: FunctionInfo): void;
   emitFunctionReturn(this: Generator, value: string): void;
   emitMain(this: Generator): void;
   functionName(this: Generator, fn: FunctionInfo): string;
@@ -192,6 +194,14 @@ export const moduleMethods: ModuleMethods = {
       this.defineCaptureSlot(symbol, value);
     }
 
+    // Hoisted function declarations: create their closure values in this
+    // frame (before the body runs) so a nested function that references one
+    // gets the closure built against the declaring frame, not against the
+    // caller's slots. Captured function symbols are boxed by the binder, so
+    // the second pass publishes the closures into those boxes and mutual
+    // recursion sees the same values.
+    this.emitHoistedFunctions(fn);
+
     // Arrow functions inherit `this` lexically; it travels as an extra capture.
     if (fn.isArrow && fn.capturesThis) {
       const inherited = this.reg();
@@ -337,6 +347,46 @@ export const moduleMethods: ModuleMethods = {
     return name;
   },
 
+  emitHoistedFunctions(fn: FunctionInfo): void {
+    if (fn.isModule) return;
+    const body = (fn.node as { body?: Block }).body;
+    if (!body || body.kind !== SyntaxKind.Block) return;
+    const declarations: FunctionDeclaration[] = [];
+    for (const statement of body.statements) {
+      if (statement.kind === SyntaxKind.FunctionDeclaration) {
+        declarations.push(statement as FunctionDeclaration);
+      }
+    }
+    if (declarations.length === 0) return;
+    /* Captured locals of this frame may be declared textually after the
+     * function that uses them. Function declarations are hoisted, so create
+     * their boxes now; the `let`/`const`/`var` statement fills the box when it
+     * runs (emitVariableStatement writes into an existing slot). */
+    for (const declaration of declarations) {
+      const child = this.binding.functionOfNode.get(declaration);
+      if (!child) continue;
+      for (const captured of child.captures) {
+        if (captured.fn !== fn) continue;
+        if (!this.current.slots.has(captured.id)) this.declareSlot(captured, i64(XT_UNDEFINED));
+      }
+    }
+    /* First pass: a slot (and a box, when captured) exists for every name
+     * before any closure is built, so sibling references cannot observe an
+     * uninitialised slot. */
+    const ready: Array<{ symbol: SymbolInfo; child: FunctionInfo }> = [];
+    for (const declaration of declarations) {
+      const symbol = this.binding.symbolOfDeclaration.get(declaration);
+      const child = this.binding.functionOfNode.get(declaration);
+      if (!symbol || !child) continue;
+      if (!this.current.slots.has(symbol.id)) this.declareSlot(symbol, i64(XT_UNDEFINED));
+      ready.push({ symbol, child });
+    }
+    /* Second pass: build and store the closures. */
+    for (const entry of ready) {
+      this.writeSlot(entry.symbol, this.emitClosureValue(entry.child));
+    }
+  },
+
   emitClassReference(classInfo: ClassInfo): string {
     const globalName = this.classGlobal(classInfo);
     const value = this.reg();

package/src/codegen/generator/statements/variables.ts

@@ -33,9 +33,12 @@ export const variableStatementMethods: VariableStatementMethods = {
           continue;
         }
         if (this.current.slots.has(symbol.id)) {
-          // Hoisted `var` (or an already-declared slot): keep evaluating the
-          // initializer for its side effects, but do not redeclare the slot.
-          if (declaration.initializer) this.emitExpression(declaration.initializer);
+          // Hoisted `var`, or a box created early for a captured binding
+          // declared textually after a hoisted function: do not redeclare the
+          // slot, but assigning an initializer is still part of the statement.
+          if (declaration.initializer) {
+            this.writeSlot(symbol, this.emitExpression(declaration.initializer));
+          }
           continue;
         }
         if (symbol.boxed) {

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.31";
+export const COMPILER_VERSION = "0.5.32";

package/src/extensions/gui/css.ts

@@ -0,0 +1,113 @@
+/**
+ * GUI extension: inline external stylesheets into the HTML asset.
+ *
+ * The engine's CSS cascade only reads `<style>` elements (`document.cpp` skips
+ * `<link rel="stylesheet">` because resolving it would need I/O at runtime).
+ * A page that ships its CSS as a separate file therefore loses *all* styling
+ * once it is compiled. The bundler, unlike the runtime, can read files, so this
+ * loader rewrites every local stylesheet link (and every local `@import` inside
+ * it) into an inline `<style>` block. The page keeps its author-time structure
+ * and the compiled binary has no runtime file dependency.
+ *
+ * Remote URLs are left untouched: there is no network-backed style loader, so
+ * the engine simply ignores them, exactly as before.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+/** Read a stylesheet as a byte string (one code unit per UTF-8 byte).
+ *
+ * The bundler hands asset loaders the same shape (`sourceTextBytes`), so CSS
+ * must join the HTML *as bytes*. Decoding it to UTF-16 and putting that into
+ * the byte-string document would make codegen encode the HTML's own bytes a
+ * second time. `toString("latin1")` is exactly the byte-string mapping; the
+ * self-hosted runtime's `readFileSync` already returns bytes. */
+function readCssText(file: string): string {
+  const data: string | Buffer = readFileSync(file);
+  return typeof data === "string" ? data : data.toString("latin1");
+}
+
+/** A resolved local stylesheet: its inlined text is returned to the caller. */
+export interface InlinedStylesheets {
+  readonly html: string;
+  /** Every stylesheet file that was read (for bundler cache invalidation). */
+  readonly dependencies: readonly string[];
+}
+
+/** True for a URL the compiler cannot read (http:, data:, //host, …). */
+const URL_SPEC = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+
+/** Read one attribute from an element's attribute text. */
+function attribute(attributes: string, name: string): string | undefined {
+  const pattern = new RegExp(
+    `(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>\`]+))`,
+    "i",
+  );
+  const match = pattern.exec(attributes);
+  if (!match) return undefined;
+  return match[1] ?? match[2] ?? match[3];
+}
+
+/** Strip a `?query` / `#fragment`, then resolve against a base file. */
+function localPath(baseFile: string, specifier: string): string | undefined {
+  if (specifier === "" || URL_SPEC.test(specifier)) return undefined;
+  const clean = specifier.split(/[?#]/, 1)[0] ?? specifier;
+  return resolve(dirname(baseFile), clean);
+}
+
+/** True when the `rel` attribute lists `stylesheet` among its tokens. */
+function isStylesheet(rel: string | undefined): boolean {
+  if (rel === undefined) return false;
+  return rel.toLowerCase().split(/\s+/).includes("stylesheet");
+}
+
+/**
+ * Inline every local `@import` in `css`. Imports are resolved relative to
+ * `cssFile`, which is the file the rules came from (not the HTML page), so a
+ * partial that imports a sibling keeps working. A cycle is cut at the repeated
+ * file rather than recursing forever.
+ */
+function inlineImports(
+  css: string,
+  cssFile: string,
+  dependencies: Set<string>,
+  stack: readonly string[],
+): string {
+  /* `@import url("./x.css") screen;` and `@import "./x.css";` are the two
+   * spellings the CSS parser accepts. Match one at a time so a single bad
+   * import cannot swallow the rest of the sheet. */
+  const pattern =
+    /@import\s+(?:url\(\s*(?:"([^"]*)"|'([^']*)'|([^'")\s]+))\s*\)|"([^"]*)"|'([^']*)')\s*[^;]*;/gi;
+  return css.replace(pattern, (match, a, b, c, d, e) => {
+    const specifier = a ?? b ?? c ?? d ?? e;
+    if (specifier === undefined) return "";
+    const file = localPath(cssFile, specifier);
+    if (file === undefined) return match;
+    if (stack.includes(file)) return "";
+    if (!existsSync(file)) return match;
+    dependencies.add(file);
+    const nested = readCssText(file);
+    return inlineImports(nested, file, dependencies, [...stack, file]);
+  });
+}
+
+/**
+ * Replace `<link rel="stylesheet">` elements with inline `<style>` blocks,
+ * recursively resolving local `@import` rules. Returns the rewritten HTML and
+ * the list of stylesheet files it read.
+ */
+export function inlineStylesheets(htmlFile: string, html: string): InlinedStylesheets {
+  const dependencies = new Set<string>();
+  const rewritten = html.replace(/<link\b([^>]*)>/gi, (match, attributes: string) => {
+    if (!isStylesheet(attribute(attributes, "rel"))) return match;
+    const href = attribute(attributes, "href");
+    if (href === undefined) return match;
+    const file = localPath(htmlFile, href);
+    if (file === undefined || !existsSync(file)) return match;
+    dependencies.add(file);
+    const css = inlineImports(readCssText(file), file, dependencies, [file]);
+    return `<style data-xt-href="${href.replace(/"/g, "&quot;")}">\n${css}\n</style>`;
+  });
+  return { html: rewritten, dependencies: [...dependencies] };
+}

package/src/extensions/gui/html.ts

@@ -38,6 +38,7 @@ import { Parser } from "../../parser/parser.js";
 import { artifactPath } from "../../canonical.js";
 import { hashString } from "../../driver/cache.js";
 import type { AssetLoadResult, AssetSourceRange } from "../registry.js";
+import { inlineStylesheets } from "./css.js";
 
 /** Matches an inline `<script …>body</script>` element, attributes included. */
 const SCRIPT_RE = /<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi;
@@ -191,7 +192,10 @@ export function loadHtmlAsset(path: string, source: string): AssetLoadResult {
   const importedText = new Set<string>();
   const bound = new Set<string>();
 
-  const html = source.replace(SCRIPT_RE, (match, attributes: string, inlineBody: string) => {
+  /* 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, source);
+  const html = styles.html.replace(SCRIPT_RE, (match, attributes: string, inlineBody: string) => {
     if (!isExecutable(attribute(attributes, "type"), attribute(attributes, "lang"))) return match;
     const src = attribute(attributes, "src");
 
@@ -244,6 +248,9 @@ export function loadHtmlAsset(path: string, source: string): AssetLoadResult {
     offset += part.length + 1;
   }
   parts.push(`export default ${JSON.stringify(html)};`);
-  const result: AssetLoadResult = { moduleSource: parts.join("\n") };
+  const result: AssetLoadResult = {
+    moduleSource: parts.join("\n"),
+    ...(styles.dependencies.length > 0 ? { dependencies: styles.dependencies } : {}),
+  };
   return sourceRanges.length > 0 ? { ...result, sourceRanges } : result;
 }

package/src/extensions/gui/index.ts

@@ -26,6 +26,7 @@ import type { Extension, ExtensionModule } from "../registry.js";
 import { findRuntimeDir, platformSlug } from "../../driver/paths.js";
 import { findRuntimeLibrary } from "../../driver/runtime-lib.js";
 import { loadHtmlAsset } from "./html.js";
+import { loadScriptAsset } from "./three.js";
 
 /** Top-level `gui` module bindings. */
 const guiModule: ExtensionModule = {
@@ -77,6 +78,19 @@ const hostTypes = [
   "ReadableStream",
   "WebGLRenderingContext",
   "WebGL2RenderingContext",
+  "WebGLBuffer",
+  "WebGLTexture",
+  "WebGLShader",
+  "WebGLProgram",
+  "WebGLFramebuffer",
+  "WebGLRenderbuffer",
+  "WebGLUniformLocation",
+  "WebGLActiveInfo",
+  "WebGLVertexArrayObject",
+  "WebGLSampler",
+  "WebGLQuery",
+  "WebGLSync",
+  "WebGLTransformFeedback",
   "XRWebGLLayer",
   "XRWebGLBinding",
 ] as const;
@@ -186,6 +200,6 @@ export const guiExtension: Extension = {
   }),
   /** Browser globals (`window`, `document`, the DOM type names). */
   globalValues: () => browserGlobals,
-  /** Rewrite imported `.html` assets (see `html.ts`). */
-  assetLoaders: () => ({ ".html": loadHtmlAsset }),
+  /** Rewrite imported `.html` assets and patch three.js's shader unroller. */
+  assetLoaders: () => ({ ".html": loadHtmlAsset, ".js": loadScriptAsset, ".mjs": loadScriptAsset }),
 };

package/src/extensions/gui/three.ts

@@ -0,0 +1,25 @@
+/**
+ * GUI extension: three.js shader-unroller compatibility.
+ *
+ * three.js's `WebGLRenderer` runs unchanged on this engine's real WebGL 2
+ * backend; no Canvas2D fallback (and no renderer wrapper) is needed. The one
+ * shader-side workaround is its `unrollLoops` pass: its lazy global regex does
+ * not behave reliably on this runtime, and the shader rewriter already defines
+ * `UNROLLED_LOOP_INDEX` and keeps the numeric `for` loop. Disabling the pattern
+ * therefore leaves valid GLSL instead of a half-expanded loop.
+ */
+
+import type { AssetLoadResult } from "../registry.js";
+
+/** three.js's unroll-loop regex declaration (r150–r16x naming). */
+const LOOP_PATTERN = /const unrollLoopPattern = [^\n]*;/;
+
+/**
+ * Patch a three.js ES module so its shaders keep their light loops. Any other
+ * `.js` asset is returned verbatim.
+ */
+export function loadScriptAsset(path: string, source: string): AssetLoadResult {
+  return {
+    moduleSource: source.replace(LOOP_PATTERN, "const unrollLoopPattern = /__xt_never_match__/;"),
+  };
+}

package/src/extensions/media/index.ts

@@ -6,8 +6,9 @@
  * so a program that only needs windows and HTML/CSS does not pay for a media
  * stack it never uses. This extension supplies the decoding half:
  *
- *   - `media.a` (built by `npm run media`) contains the FFmpeg-linked player
- *     from `runtime/ext_media/media.cpp` and the static FFmpeg libraries;
+ *   - `media.a` (`media.lib` with the MSVC ABI on Windows, built by
+ *     `npm run media`) contains the FFmpeg-linked player from
+ *     `runtime/ext_media/media.cpp` and the static FFmpeg libraries;
  *   - `runtime/ext_media/media_bridge.c` is compiled and linked directly. Its
  *     constructor installs the player table into the GUI engine and references
  *     the backend entry points, which makes the linker extract the archive
@@ -19,9 +20,9 @@
  *
  *     xbintsc run app.ts --ext gui,media
  *
- * The archive is POSIX-only for now (the build needs FFmpeg's `configure` and
- * an MSVC-compatible FFmpeg has not been built), so Windows reports an
- * actionable error instead of linking an inert element.
+ * The archive is built for every host platform. On Windows FFmpeg is compiled
+ * with the MSVC-targeting clang-cl so its COFF objects and static CRT match
+ * `gui.lib`; see `doc/gui/build.md`.
  */
 
 import { join } from "node:path";
@@ -31,7 +32,7 @@ import { findRuntimeLibrary } from "../../driver/runtime-lib.js";
 
 /** Absolute path to the per-platform prebuilt media archive. */
 function mediaArchive(): string {
-  return join(findRuntimeDir(), "lib", platformSlug(), "media.a");
+  return join(findRuntimeDir(), "lib", platformSlug(), process.platform === "win32" ? "media.lib" : "media.a");
 }
 
 export const mediaExtension: Extension = {
@@ -45,23 +46,19 @@ export const mediaExtension: Extension = {
    */
   runtimeSources: () => [join(findRuntimeDir(), "ext_media", "media_bridge.c")],
   nativeObjects: () => {
-    if (process.platform === "win32") {
-      throw new Error(
-        "the media extension is not available on Windows yet: it needs an MSVC-compatible " +
-          "FFmpeg build (see doc/gui/known-issues.md). Build without --ext media; media " +
-          "elements then report an 'error' event.",
-      );
-    }
     const archive = findRuntimeLibrary("media");
     if (archive === undefined) {
       throw new Error(
-        `media native library not found at ${mediaArchive()} (or media.lib).\n` +
+        `media native library not found at ${mediaArchive()} (media.a or media.lib).\n` +
           `Build it for ${platformSlug()} first with \`npm run media\` (see doc/gui/build.md).`,
       );
     }
     return [archive];
   },
   /** `media.a` is C++ and FFmpeg itself needs libm; the GUI extension already
-   * contributes the C++ runtime and the OS frameworks. */
-  linkerFlags: () => (process.platform === "win32" ? [] : ["-lm"]),
+   * contributes the C++ runtime and the OS frameworks. On Windows the FFmpeg
+   * objects reference the Win32 crypto/COM services (`bcrypt`, `ole32`) and
+   * `user32`. */
+  linkerFlags: () =>
+    process.platform === "win32" ? ["-lbcrypt", "-lole32", "-luser32"] : ["-lm"],
 };