xbintsc 0.5.32 → 0.5.37

package/src/driver/runtime-lib.ts

@@ -7,26 +7,90 @@
  *   runtime/lib/<os>-<arch>/core.a        (the core `xt_*.c` runtime)
  *   runtime/lib/<os>-<arch>/ext_<name>.a  (per-extension sources, e.g. ext_node.a)
  *
+ * A source checkout or a release archive carries them in the package itself.
+ * An npm install instead receives them from the optional
+ * `@xbintsc/<os>-<arch>` package (installed only for the host platform), which
+ * uses the same `runtime/lib/<os>-<arch>/` layout. The driver reads that folder
+ * in place, so no install script has to copy anything into `node_modules`.
+ *
  * Shipping these lets `build` link without compiling C, and shortens the first
  * build. When an archive is missing the driver transparently falls back to
  * compiling the `.c` sources, so the archives are an optimization, not a hard
  * dependency.
  */
 
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { findRuntimeDir, platformSlug } from "./paths.js";
 
-/** Directory holding the prebuilt archives for the current host. */
-export function runtimeLibDir(): string {
+/** Archive suffixes, in the order a name is probed. */
+const ARCHIVE_SUFFIXES = [".a", ".lib"] as const;
+
+/**
+ * Folder holding the archives for the current host inside the xbintsc package
+ * itself (a source checkout or an unpacked release archive).
+ */
+function packagedRuntimeLibDir(): string {
   return join(findRuntimeDir(), "lib", platformSlug());
 }
 
-/** Absolute path to a prebuilt archive (`core`, `ext_node`, …), if present. */
-export function findRuntimeLibrary(name: string): string | undefined {
-  const base = join(runtimeLibDir(), name);
-  for (const candidate of [`${base}.a`, `${base}.lib`]) {
-    if (existsSync(candidate)) return candidate;
+/**
+ * Archive folders of an installed `@xbintsc/<os>-<arch>` package, given the
+ * root of the installed xbintsc package.
+ *
+ * Package managers place the optional dependency either inside xbintsc's own
+ * `node_modules` or in the nearest hoisted `node_modules`, so every ancestor is
+ * probed. Yarn PnP has no `node_modules`; there the driver simply falls back to
+ * compiling the runtime sources.
+ */
+export function platformRuntimeLibDirs(packageRoot: string, slug: string = platformSlug()): string[] {
+  const dirs = new Set<string>();
+  let dir = packageRoot;
+  for (;;) {
+    dirs.add(join(dir, "node_modules", "@xbintsc", slug, "runtime", "lib", slug));
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return [...dirs];
+}
+
+/** Every folder searched for a prebuilt archive, most specific first. */
+export function runtimeLibDirs(): readonly string[] {
+  return [packagedRuntimeLibDir(), ...platformRuntimeLibDirs(dirname(findRuntimeDir()))];
+}
+
+/** True when a folder holds at least one runtime archive. */
+function containsArchive(dir: string): boolean {
+  try {
+    return readdirSync(dir).some((entry) => ARCHIVE_SUFFIXES.some((suffix) => entry.endsWith(suffix)));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Directory holding the prebuilt archives for the current host: the package's
+ * own `runtime/lib/<slug>`, or the optional platform package when the former
+ * has no archives (a normal npm install).
+ */
+export function runtimeLibDir(dirs: readonly string[] = runtimeLibDirs()): string {
+  return dirs.find((dir) => containsArchive(dir)) ?? dirs[0]!;
+}
+
+/**
+ * Absolute path to a prebuilt archive (`core`, `ext_node`, `gui`, `media`, …),
+ * if present. `dirs` is injectable for tests.
+ */
+export function findRuntimeLibrary(
+  name: string,
+  dirs: readonly string[] = runtimeLibDirs(),
+): string | undefined {
+  for (const dir of dirs) {
+    for (const suffix of ARCHIVE_SUFFIXES) {
+      const candidate = join(dir, `${name}${suffix}`);
+      if (existsSync(candidate)) return candidate;
+    }
   }
   return undefined;
 }

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

package/src/extensions/gui/index.ts

@@ -23,8 +23,8 @@
 
 import { join } from "node:path";
 import type { Extension, ExtensionModule } from "../registry.js";
-import { findRuntimeDir, platformSlug } from "../../driver/paths.js";
-import { findRuntimeLibrary } from "../../driver/runtime-lib.js";
+import { platformSlug } from "../../driver/paths.js";
+import { findRuntimeLibrary, runtimeLibDir } from "../../driver/runtime-lib.js";
 import { loadHtmlAsset } from "./html.js";
 import { loadScriptAsset } from "./three.js";
 
@@ -61,6 +61,7 @@ const hostTypes = [
   "ImageBitmap",
   "ImageData",
   "HTMLCanvasElement",
+  "Path2D",
   "HTMLImageElement",
   "HTMLVideoElement",
   "HTMLAudioElement",
@@ -70,6 +71,16 @@ const hostTypes = [
   "Event",
   "CustomEvent",
   "ProgressEvent",
+  "UIEvent",
+  "MouseEvent",
+  "PointerEvent",
+  "WheelEvent",
+  "KeyboardEvent",
+  "FocusEvent",
+  "InputEvent",
+  "SubmitEvent",
+  "AbortController",
+  "AbortSignal",
   "EventTarget",
   "DOMParser",
   "Request",
@@ -102,7 +113,7 @@ const browserGlobals: Record<string, { symbol: string; argument?: string }> = {
   navigator: { symbol: "xt_browser_navigator" },
   localStorage: { symbol: "xt_browser_local_storage" },
   __THREE_DEVTOOLS__: { symbol: "xt_browser_missing" },
-  createImageBitmap: { symbol: "xt_browser_missing" },
+  createImageBitmap: { symbol: "xt_browser_create_image_bitmap" },
 };
 for (const type of hostTypes) {
   browserGlobals[type] = { symbol: "xt_browser_type", argument: type };
@@ -111,7 +122,7 @@ for (const type of hostTypes) {
 /** Absolute path to the per-platform prebuilt GUI archive (`gui.a`, or
  * `gui.lib` with the MSVC ABI on Windows). */
 function guiArchive(): string {
-  return join(findRuntimeDir(), "lib", platformSlug(), "gui.a");
+  return join(runtimeLibDir(), "gui.a");
 }
 
 export const guiExtension: Extension = {
@@ -122,7 +133,8 @@ export const guiExtension: Extension = {
     if (archive === undefined) {
       throw new Error(
         `GUI native library not found at ${guiArchive()} (or gui.lib).\n` +
-          `Build it for ${platformSlug()} first (see doc/gui.md).`,
+          `The optional @xbintsc/${platformSlug()} package ships it: reinstall xbintsc ` +
+          `without --omit=optional, or build it from a source checkout (see doc/gui.md).`,
       );
     }
     return [archive];
@@ -197,6 +209,7 @@ export const guiExtension: Extension = {
     escape: { symbol: "xt_browser_escape" },
     alert: { symbol: "xt_browser_alert" },
     prompt: { symbol: "xt_browser_prompt" },
+    confirm: { symbol: "xt_browser_confirm_global" },
   }),
   /** Browser globals (`window`, `document`, the DOM type names). */
   globalValues: () => browserGlobals,

package/src/extensions/media/index.ts

@@ -28,11 +28,11 @@
 import { join } from "node:path";
 import type { Extension } from "../registry.js";
 import { findRuntimeDir, platformSlug } from "../../driver/paths.js";
-import { findRuntimeLibrary } from "../../driver/runtime-lib.js";
+import { findRuntimeLibrary, runtimeLibDir } from "../../driver/runtime-lib.js";
 
 /** Absolute path to the per-platform prebuilt media archive. */
 function mediaArchive(): string {
-  return join(findRuntimeDir(), "lib", platformSlug(), process.platform === "win32" ? "media.lib" : "media.a");
+  return join(runtimeLibDir(), process.platform === "win32" ? "media.lib" : "media.a");
 }
 
 export const mediaExtension: Extension = {
@@ -50,7 +50,8 @@ export const mediaExtension: Extension = {
     if (archive === undefined) {
       throw new Error(
         `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).`,
+          `The optional @xbintsc/${platformSlug()} package ships it: reinstall xbintsc ` +
+          `without --omit=optional, or build it with \`npm run media\` (see doc/gui/build.md).`,
       );
     }
     return [archive];

package/src/parser/context.ts

@@ -15,11 +15,25 @@ import { SyntaxKind } from "../ast/kinds.js";
 import type { Identifier, StringLiteral } from "../ast/nodes.js";
 import { SpeculationError } from "./speculation.js";
 
+/**
+ * The template-literal context of the scanner at one point in the token
+ * stream. `frames` holds the brace depth of every open `${ … }` substitution
+ * (innermost last); `pendingOffset` is the `}` that must be re-read as template
+ * text before the next token is scanned.
+ */
+interface TemplateState {
+  readonly frames: readonly number[];
+  readonly pendingOffset: number | undefined;
+}
+
+const OUTSIDE_TEMPLATE: TemplateState = { frames: [], pendingOffset: undefined };
+
 export interface ParserState {
   index: number;
   tokens: Token[];
   pos: number;
   consumed: number;
+  template: TemplateState;
 }
 
 export class ParserContext {
@@ -32,12 +46,22 @@ export class ParserContext {
   speculating = 0;
   /** Monotonic count of tokens consumed; used to detect lack of progress. */
   consumed = 0;
+  /** Brace depth of each open `${ … }` substitution, innermost last. */
+  private templateFrames: number[] = [];
+  /** Offset of the `}` that must be re-read as template text on the next scan. */
+  private pendingTemplateOffset: number | undefined;
+  /**
+   * Template context after each buffered token. A parser method that rewinds
+   * the scanner (the regex fallback) restores the context recorded on the
+   * current token so a template that was only seen by lookahead stays coherent.
+   */
+  private readonly templateStates = new WeakMap<Token, TemplateState>();
 
   constructor(source: SourceFile, diagnostics: DiagnosticBag) {
     this.source = source;
     this.diagnostics = diagnostics;
     this.scanner = new Scanner(source, diagnostics);
-    this.tokens = [this.scanner.nextToken()];
+    this.tokens = [this.scanToken()];
   }
 
   // -- token access ---------------------------------------------------------
@@ -61,7 +85,7 @@ export class ParserContext {
 
   lookAhead(k: number): Token {
     while (this.tokens.length <= this.index + k) {
-      this.tokens.push(this.scanner.nextToken());
+      this.tokens.push(this.scanToken());
     }
     return this.tokens[this.index + k]!;
   }
@@ -72,12 +96,76 @@ export class ParserContext {
     if (this.index + 1 < this.tokens.length) {
       this.index++;
     } else {
-      this.tokens = [this.scanner.nextToken()];
+      this.tokens = [this.scanToken()];
       this.index = 0;
     }
     return current;
   }
 
+  /**
+   * Scan the next token, keeping a template literal together. A `${ … }`
+   * substitution is ordinary token stream (so the parser can parse the
+   * expression), but the `}` that closes it must be followed by a token that
+   * re-reads the source as template text. Scanning the tail of a template as
+   * normal tokens would let its raw text (quotes, parens, `}`) leak into
+   * lookahead - and `findMatchingParen` would then count characters that are
+   * part of the literal.
+   */
+  private scanToken(): Token {
+    let token: Token;
+    if (this.pendingTemplateOffset !== undefined) {
+      const offset = this.pendingTemplateOffset;
+      this.pendingTemplateOffset = undefined;
+      token = this.scanner.continueTemplate(offset);
+      if (token.kind === TokenKind.NoSubstitutionTemplateLiteral) {
+        this.templateFrames.pop();
+      } else if (token.kind === TokenKind.TemplateHead) {
+        /* Another `${` in the same template restarts its brace depth. */
+        const top = this.templateFrames.length - 1;
+        if (top >= 0) this.templateFrames[top] = 0;
+      }
+    } else {
+      token = this.scanner.nextToken();
+      if (token.kind === TokenKind.TemplateHead) {
+        this.templateFrames.push(0);
+      } else if (this.templateFrames.length > 0) {
+        const top = this.templateFrames.length - 1;
+        if (token.kind === TokenKind.OpenBrace) {
+          this.templateFrames[top] = this.templateFrames[top]! + 1;
+        } else if (token.kind === TokenKind.CloseBrace) {
+          if (this.templateFrames[top]! === 0) this.pendingTemplateOffset = token.start;
+          else this.templateFrames[top] = this.templateFrames[top]! - 1;
+        }
+      }
+    }
+    if (this.templateFrames.length > 0 || this.pendingTemplateOffset !== undefined) {
+      this.templateStates.set(token, this.snapshotTemplateState());
+    }
+    return token;
+  }
+
+  /**
+   * Discard any lookahead and continue scanning at `offset`. Used when a
+   * literal's raw text has to be re-read (the regex fallback). The template
+   * context is restored to the state recorded for the current token, because
+   * the skipped source cannot have opened or closed a template.
+   */
+  rescanFrom(offset: number): void {
+    this.restoreTemplateState(this.templateStates.get(this.token) ?? OUTSIDE_TEMPLATE);
+    this.scanner.seek(offset);
+    this.tokens = [this.scanToken()];
+    this.index = 0;
+  }
+
+  private snapshotTemplateState(): TemplateState {
+    return { frames: this.templateFrames.slice(), pendingOffset: this.pendingTemplateOffset };
+  }
+
+  private restoreTemplateState(state: TemplateState): void {
+    this.templateFrames = [...state.frames];
+    this.pendingTemplateOffset = state.pendingOffset;
+  }
+
   parseExpected(kind: TokenKind, message?: string): Token {
     if (this.token.kind === kind) return this.nextToken();
     this.error(
@@ -173,7 +261,13 @@ export class ParserContext {
   // -- state save / restore (for speculative parsing) -----------------------
 
   saveState(): ParserState {
-    return { index: this.index, tokens: this.tokens.slice(), pos: this.scanner.position, consumed: this.consumed };
+    return {
+      index: this.index,
+      tokens: this.tokens.slice(),
+      pos: this.scanner.position,
+      consumed: this.consumed,
+      template: this.snapshotTemplateState(),
+    };
   }
 
   restoreState(state: ParserState): void {
@@ -181,5 +275,6 @@ export class ParserContext {
     this.tokens = state.tokens;
     this.scanner.seek(state.pos);
     this.consumed = state.consumed;
+    this.restoreTemplateState(state.template);
   }
 }

package/src/parser/literals.ts

@@ -206,10 +206,8 @@ export const literalMethods: LiteralMethods = {
       } as unknown as TemplateLiteral;
     }
     if (startToken.kind === TokenKind.Backtick) {
-      // Re-scan from the backtick so the scanner produces a TemplateHead.
-      this.scanner.seek(startToken.start);
-      this.tokens = [this.scanner.nextToken()];
-      this.index = 0;
+      // Re-scan from the backtick so the scanner produces a template token.
+      this.rescanFrom(startToken.start);
       return this.parseTemplateLiteral();
     }
     const head = String(startToken.value ?? "");
@@ -222,11 +220,9 @@ export const literalMethods: LiteralMethods = {
         this.error(DiagnosticCode.UnterminatedTemplate, "Expected '}' to close template substitution");
         return { kind: SyntaxKind.TemplateLiteral, head, raw: headRaw, spans, start: startToken.start, end: this.token.end };
       }
-      // The `}` terminates a substitution; re-read it as template text without
-      // first scanning the following (template) characters as normal tokens.
-      const closeStart = this.token.start;
-      this.tokens = [this.scanner.continueTemplate(closeStart)];
-      this.index = 0;
+      // The `}` terminates a substitution; the token after it is the template
+      // continuation (the token stream re-reads that source as literal text).
+      this.nextToken();
       const literalToken = this.token;
       if (literalToken.kind === TokenKind.NoSubstitutionTemplateLiteral) {
         this.nextToken();
@@ -287,9 +283,7 @@ export const literalMethods: LiteralMethods = {
     const flagsStart = i;
     while (i < text.length && /[a-z]/i.test(text[i]!)) i++;
     const flags = text.slice(flagsStart, i);
-    this.scanner.seek(i);
-    this.tokens = [this.scanner.nextToken()];
-    this.index = 0;
+    this.rescanFrom(i);
     return { kind: SyntaxKind.RegularExpressionLiteral, text: text.slice(token.start, i), pattern, flags, start: token.start, end: i };
   },
 };