xbintsc 0.3.46 → 0.3.61

package/runtime/ext_gui/renderer_text.cpp

@@ -187,22 +187,26 @@ void flushAtlas(SDL_GPUDevice *device) {
 }
 
 SDL_GPUGraphicsPipeline *createTextPipeline(SDL_GPUDevice *device, SDL_Window *reference) {
+  const ShaderSource text_vs = selectShader(device, ShaderProgram::Text, false);
+  const ShaderSource text_fs = selectShader(device, ShaderProgram::Text, true);
+  if (!text_vs.valid() || !text_fs.valid()) return nullptr;
+
   SDL_GPUShaderCreateInfo vs_info;
   memset(&vs_info, 0, sizeof(vs_info));
-  vs_info.code_size = strlen(kTextMSL);
-  vs_info.code = (const Uint8 *)kTextMSL;
-  vs_info.entrypoint = "vs_text";
-  vs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  vs_info.code_size = text_vs.size;
+  vs_info.code = text_vs.code;
+  vs_info.entrypoint = text_vs.entry;
+  vs_info.format = text_vs.format;
   vs_info.stage = SDL_GPU_SHADERSTAGE_VERTEX;
   vs_info.num_uniform_buffers = 1;
   SDL_GPUShader *vs = SDL_CreateGPUShader(device, &vs_info);
 
   SDL_GPUShaderCreateInfo fs_info;
   memset(&fs_info, 0, sizeof(fs_info));
-  fs_info.code_size = strlen(kTextMSL);
-  fs_info.code = (const Uint8 *)kTextMSL;
-  fs_info.entrypoint = "fs_text";
-  fs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  fs_info.code_size = text_fs.size;
+  fs_info.code = text_fs.code;
+  fs_info.entrypoint = text_fs.entry;
+  fs_info.format = text_fs.format;
   fs_info.stage = SDL_GPU_SHADERSTAGE_FRAGMENT;
   fs_info.num_samplers = 1;
   SDL_GPUShader *fs = SDL_CreateGPUShader(device, &fs_info);

package/runtime/ext_gui/script.cpp

@@ -15,8 +15,11 @@
 #include <unordered_map>
 #include <vector>
 
-/** Script id -> AOT-compiled function value. Lives for the whole process (the
- * runtime arena never reclaims, so storing `xt_value`s is safe). */
+/** Script id -> AOT-compiled function value. Lives for the whole process. The
+ * runtime collector is a mark-sweep over the heap, so these values are only
+ * safe while a root provider keeps them reachable — `xt_gui_script_gc_scan`
+ * below does that (without it a collection frees everything the script
+ * captured and the first frame after it crashes). */
 static std::unordered_map<std::string, xt_value> &script_registry() {
   static std::unordered_map<std::string, xt_value> registry;
   return registry;
@@ -31,9 +34,16 @@ extern "C" xt_value xt_register_script(int32_t argc, xt_value *argv) {
       script_registry()[std::string(id)] = fn;
     }
   }
+  /* Registration is idempotent; do it on first use so a program that never
+   * opens a window still keeps its scripts alive across a collection. */
+  xt_gc_register_root_provider(xt_gui_script_gc_scan);
   return XT_UNDEFINED;
 }
 
+void xt_gui_script_gc_scan(void) {
+  for (const auto &entry : script_registry()) xt_gc_mark_value(entry.second);
+}
+
 /** Collect `data-xt-id` markers from `<script>` elements, in document order. */
 static void collect_script_ids(const xtgui::Node *node, std::vector<std::string> &ids) {
   if (node == nullptr) return;

package/runtime/ext_gui/shaders.hlsl

@@ -0,0 +1,98 @@
+/*
+ * xbintsc GUI engine — shader sources compiled ahead of time into the embedded
+ * blobs in `renderer_blobs.h`.
+ *
+ * Three programs, two entry points each:
+ *   - `vs_main` / `fs_main`   rounded-rectangle fills
+ *   - `vs_text` / `fs_text`   glyph quads (single-channel atlas)
+ *   - `vs_text` / `fs_image`  image quads (RGBA texture)
+ *
+ * `vs_main` and `vs_text` are identical in effect; they are kept separate so the
+ * Metal (MSL) path keeps its distinct entry-point names, and this file is the
+ * HLSL half of the pair. Vertex attribute semantics map 1:1 onto
+ * `SDL_GPUVertexAttribute.location`, and the push constant becomes `b0`.
+ *
+ * Compile with (Windows SDK `dxc`):
+ *   dxc -T vs_6_0 -E vs_main  -Fo fill_vs.dxil  shaders.hlsl
+ *   dxc -T ps_6_0 -E fs_main  -Fo fill_fs.dxil  shaders.hlsl
+ *   dxc -T vs_6_0 -E vs_text  -Fo text_vs.dxil  shaders.hlsl
+ *   dxc -T ps_6_0 -E fs_text  -Fo text_fs.dxil  shaders.hlsl
+ *   dxc -T ps_6_0 -E fs_image -Fo image_fs.dxil shaders.hlsl
+ */
+
+cbuffer Viewport : register(b0) { float2 viewport; };
+
+/* -- fills ---------------------------------------------------------------- */
+
+struct FillIn {
+    float2 position : TEXCOORD0;
+    float2 local    : TEXCOORD1;
+    float2 halfsize : TEXCOORD2;
+    float  radius   : TEXCOORD3;
+    float4 color    : TEXCOORD4;
+};
+
+struct FillOut {
+    float4 position : SV_Position;
+    float2 local    : TEXCOORD1;
+    float2 halfsize : TEXCOORD2;
+    float  radius   : TEXCOORD3;
+    float4 color    : TEXCOORD4;
+};
+
+FillOut vs_main(FillIn input) {
+    FillOut output;
+    float2 ndc = float2(input.position.x / viewport.x * 2.0 - 1.0,
+                        1.0 - input.position.y / viewport.y * 2.0);
+    output.position = float4(ndc, 0.0, 1.0);
+    output.local = input.local;
+    output.halfsize = input.halfsize;
+    output.radius = input.radius;
+    output.color = input.color;
+    return output;
+}
+
+float4 fs_main(FillOut input) : SV_Target {
+    float2 d = abs(input.local) - input.halfsize + input.radius;
+    float dist = min(max(d.x, d.y), 0.0) + length(max(d, 0.0)) - input.radius;
+    float aa = max(fwidth(dist), 0.0001);
+    float alpha = clamp(0.5 - dist / aa, 0.0, 1.0);
+    return float4(input.color.rgb, input.color.a * alpha);
+}
+
+/* -- text and images ------------------------------------------------------ */
+
+struct TextIn {
+    float2 position : TEXCOORD0;
+    float2 uv       : TEXCOORD1;
+    float4 color    : TEXCOORD2;
+};
+
+struct TextOut {
+    float4 position : SV_Position;
+    float2 uv       : TEXCOORD1;
+    float4 color    : TEXCOORD2;
+};
+
+Texture2D    atlas : register(t0);
+SamplerState samp  : register(s0);
+
+TextOut vs_text(TextIn input) {
+    TextOut output;
+    float2 ndc = float2(input.position.x / viewport.x * 2.0 - 1.0,
+                        1.0 - input.position.y / viewport.y * 2.0);
+    output.position = float4(ndc, 0.0, 1.0);
+    output.uv = input.uv;
+    output.color = input.color;
+    return output;
+}
+
+float4 fs_text(TextOut input) : SV_Target {
+    float coverage = atlas.Sample(samp, input.uv).r;
+    return float4(input.color.rgb, input.color.a * coverage);
+}
+
+float4 fs_image(TextOut input) : SV_Target {
+    float4 c = atlas.Sample(samp, input.uv);
+    return float4(c.rgb * input.color.rgb, c.a * input.color.a);
+}

package/runtime/ext_gui/spirv/fill.frag

@@ -0,0 +1,19 @@
+#version 450
+
+/* xbintsc GUI engine — rounded-rectangle fill fragment shader (Vulkan/SPIR-V).
+ * The distance field mirrors the MSL/DXIL fill shaders. */
+
+layout(location = 0) in vec2 v_local;
+layout(location = 1) in vec2 v_halfsize;
+layout(location = 2) in float v_radius;
+layout(location = 3) in vec4 v_color;
+
+layout(location = 0) out vec4 out_color;
+
+void main() {
+    vec2 d = abs(v_local) - v_halfsize + v_radius;
+    float dist = min(max(d.x, d.y), 0.0) + length(max(d, 0.0)) - v_radius;
+    float aa = max(fwidth(dist), 0.0001);
+    float alpha = clamp(0.5 - dist / aa, 0.0, 1.0);
+    out_color = vec4(v_color.rgb, v_color.a * alpha);
+}

package/runtime/ext_gui/spirv/fill.vert

@@ -0,0 +1,42 @@
+#version 450
+
+/* xbintsc GUI engine — rounded-rectangle fill, Vulkan/SPIR-V path.
+ *
+ * The descriptor layout matches what SDL_GPU's Vulkan backend builds
+ * (`SDL_gpu_vulkan.c`, `CreateDescriptorSetLayout`): uniforms at
+ * `set=1, binding=0`, and (in the text/image shaders) samplers at
+ * `set=2, binding=0` with textures at `set=2, binding=1`.
+ *
+ * Vertex attributes (matching SDL_GPUVertexAttribute.location):
+ *   0 -> position (pixels, viewport-relative)
+ *   1 -> local    (pixels, relative to the rectangle centre)
+ *   2 -> halfsize (rectangle half extents, pixels)
+ *   3 -> radius   (pixels)
+ *   4 -> colour
+ * The push constant is the viewport size in logical pixels.
+ */
+
+layout(location = 0) in vec2 in_position;
+layout(location = 1) in vec2 in_local;
+layout(location = 2) in vec2 in_halfsize;
+layout(location = 3) in float in_radius;
+layout(location = 4) in vec4 in_color;
+
+layout(location = 0) out vec2 v_local;
+layout(location = 1) out vec2 v_halfsize;
+layout(location = 2) out float v_radius;
+layout(location = 3) out vec4 v_color;
+
+layout(set = 1, binding = 0) uniform Viewport {
+    vec2 size;
+} viewport;
+
+void main() {
+    vec2 ndc = vec2(in_position.x / viewport.size.x * 2.0 - 1.0,
+                    1.0 - in_position.y / viewport.size.y * 2.0);
+    gl_Position = vec4(ndc, 0.0, 1.0);
+    v_local = in_local;
+    v_halfsize = in_halfsize;
+    v_radius = in_radius;
+    v_color = in_color;
+}

package/runtime/ext_gui/spirv/image.frag

@@ -0,0 +1,16 @@
+#version 450
+
+/* xbintsc GUI engine — image quads (Vulkan/SPIR-V): sample an RGBA texture and
+ * modulate it by the vertex colour. */
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 1) in vec4 v_color;
+
+layout(location = 0) out vec4 out_color;
+
+layout(set = 2, binding = 0) uniform sampler2D image;
+
+void main() {
+    vec4 c = texture(image, v_uv);
+    out_color = vec4(c.rgb * v_color.rgb, c.a * v_color.a);
+}

package/runtime/ext_gui/spirv/quad.vert

@@ -0,0 +1,30 @@
+#version 450
+
+/* xbintsc GUI engine — glyph and image quads, Vulkan/SPIR-V path.
+ *
+ * The vertex stage is shared by both: the fragment stage differs only in how it
+ * uses the sampled texture (`fs_text` reads the atlas' red channel, `fs_image`
+ * modulates an RGBA texture). Attributes:
+ *   0 -> position (pixels, viewport-relative)
+ *   1 -> uv (atlas coordinates in [0,1])
+ *   2 -> colour
+ */
+
+layout(location = 0) in vec2 in_position;
+layout(location = 1) in vec2 in_uv;
+layout(location = 2) in vec4 in_color;
+
+layout(location = 0) out vec2 v_uv;
+layout(location = 1) out vec4 v_color;
+
+layout(set = 1, binding = 0) uniform Viewport {
+    vec2 size;
+} viewport;
+
+void main() {
+    vec2 ndc = vec2(in_position.x / viewport.size.x * 2.0 - 1.0,
+                    1.0 - in_position.y / viewport.size.y * 2.0);
+    gl_Position = vec4(ndc, 0.0, 1.0);
+    v_uv = in_uv;
+    v_color = in_color;
+}

package/runtime/ext_gui/spirv/text.frag

@@ -0,0 +1,16 @@
+#version 450
+
+/* xbintsc GUI engine — glyph quads (Vulkan/SPIR-V): sample the single-channel
+ * atlas and modulate alpha by its coverage. */
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 1) in vec4 v_color;
+
+layout(location = 0) out vec4 out_color;
+
+layout(set = 2, binding = 0) uniform sampler2D atlas;
+
+void main() {
+    float coverage = texture(atlas, v_uv).r;
+    out_color = vec4(v_color.rgb, v_color.a * coverage);
+}

package/runtime/ext_gui/text.cpp

@@ -46,10 +46,21 @@ namespace {
 const char *const kSansCandidates[] = {
     /* Explicit override wins (also checked per family class below). */
     nullptr,
+    /* Fonts with CJK coverage come first: the default face is a single face, so
+     * it has to be able to render Chinese/Japanese/Korean text as well as
+     * Latin (see "Implemented text" in doc/gui.md). */
+    "C:\\Windows\\Fonts\\msyh.ttc",      /* Microsoft YaHei (Win 8.1+) */
+    "C:\\Windows\\Fonts\\msyh.ttf",      /* Microsoft YaHei (Win 7) */
+    "C:\\Windows\\Fonts\\Deng.ttf",      /* DengXian */
+    "C:\\Windows\\Fonts\\simsun.ttc",    /* SimSun */
+    "/System/Library/Fonts/PingFang.ttc",
+    "/System/Library/Fonts/STHeiti Light.ttc",
     "/System/Library/Fonts/Helvetica.ttc",
     "/System/Library/Fonts/Supplemental/Arial.ttf",
     "/System/Library/Fonts/Supplemental/Verdana.ttf",
     "/Library/Fonts/Arial.ttf",
+    "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+    "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",
     "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
     "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
     "/usr/share/fonts/TTF/DejaVuSans.ttf",
@@ -60,10 +71,13 @@ const char *const kSansCandidates[] = {
 
 const char *const kMonoCandidates[] = {
     nullptr,
+    "C:\\Windows\\Fonts\\msyh.ttc",      /* CJK-capable fallback (see above) */
+    "/System/Library/Fonts/PingFang.ttc",
     "/System/Library/Fonts/Menlo.ttc",
     "/System/Library/Fonts/Supplemental/Courier New.ttf",
     "/System/Library/Fonts/Courier.ttc",
     "/Library/Fonts/Courier New.ttf",
+    "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
     "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
     "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf",
     "/usr/share/fonts/TTF/DejaVuSansMono.ttf",

package/runtime/ext_gui/window.cpp

@@ -283,6 +283,17 @@ static xt_value win_is_open(xt_value self, xt_value env, int32_t argc, xt_value
   return (win != NULL && win->open) ? XT_TRUE : XT_FALSE;
 }
 
+/** `/driver`: which SDL_GPU backend the device is running (`"vulkan"`,
+ * `"direct3d12"`, `"metal"`, …). The engine asks SDL for the best available
+ * one, so this is how a program (or a test) confirms the path in use. */
+static xt_value win_driver(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)self;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_string_from_cstr(xt_gui_driver());
+}
+
 /** `requestAnimationFrame(fn)` -> id. The callback runs once on the next frame
  * with the frame timestamp (ms) as its only argument. */
 static xt_value win_request_animation_frame(xt_value self, xt_value env, int32_t argc,
@@ -455,6 +466,7 @@ xt_value xt_gui_window_proto(void) {
   define_method(proto, "fontMetrics", (void *)win_font_metrics);
   define_method(proto, "close", (void *)win_close);
   define_method(proto, "isOpen", (void *)win_is_open);
+  define_method(proto, "driver", (void *)win_driver);
   define_method(proto, "requestAnimationFrame", (void *)win_request_animation_frame);
   define_method(proto, "cancelAnimationFrame", (void *)win_cancel_animation_frame);
   define_method(proto, "on", (void *)win_on);

package/runtime/rt.h

@@ -371,6 +371,16 @@ size_t xt_heap_allocations(void);
  */
 void xt_gc_add_root(xt_value *slot);
 void xt_gc_add_root_range(xt_value *base, size_t count);
+/**
+ * Register a provider that marks a subsystem's live set when the values are
+ * not reachable through value slots (the event loop's timers, a promise
+ * microtask queue, an extension that caches values in its own containers).
+ * Providers run during every collection and registration is idempotent.
+ */
+void xt_gc_register_root_provider(void (*provider)(void));
+/** Mark `value` (and everything reachable from it) as live. Root providers use
+ * this; the collector also marks explicitly registered slots and the C stack. */
+void xt_gc_mark_value(xt_value value);
 
 #ifdef __cplusplus
 }

package/scripts/build-gui-shaders.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+/**
+ * Compile the GUI engine's shaders ahead of time and embed them in
+ * `runtime/ext_gui/renderer_shaders_data.h`.
+ *
+ * SDL_GPU cannot compile GLSL or HLSL at runtime: each backend consumes its own
+ * binary format. The engine therefore ships:
+ *
+ *   - SPIR-V, for Vulkan, compiled from `runtime/ext_gui/spirv/*.{vert,frag}`
+ *     with `glslc` (from the Vulkan SDK); and
+ *   - DXIL, for Direct3D 12, compiled from `runtime/ext_gui/shaders.hlsl` with
+ *     `dxc` (inside the Windows SDK).
+ *
+ * Metal needs no blob: SDL compiles the MSL literals in `renderer_shaders.h` at
+ * runtime.
+ *
+ * The generated header is committed so a machine without either compiler (Linux,
+ * macOS CI) still builds the engine; only the corresponding backend is
+ * unavailable there.
+ *
+ * Environment:
+ *   xbintsc_GLSLC  explicit `glslc` path (default: newest `C:\VulkanSDK\*`)
+ *   xbintsc_DXC    explicit `dxc` path (default: newest Windows SDK)
+ *
+ * Usage:
+ *   node scripts/build-gui-shaders.mjs          # regenerate the header
+ *   node scripts/build-gui-shaders.mjs --check  # fail if it is out of date
+ */
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const engineDir = join(root, "runtime", "ext_gui");
+const glslDir = join(engineDir, "spirv");
+const hlsl = join(engineDir, "shaders.hlsl");
+const header = join(engineDir, "renderer_shaders_data.h");
+const scratch = join(root, "build", "gui-shaders");
+
+/** SPIR-V programs: GLSL source file and the symbol to emit. */
+const SPIRV_PROGRAMS = [
+  { source: "fill.vert", symbol: "kFillSpirvVs" },
+  { source: "fill.frag", symbol: "kFillSpirvFs" },
+  { source: "quad.vert", symbol: "kTextSpirvVs" },
+  { source: "text.frag", symbol: "kTextSpirvFs" },
+  { source: "image.frag", symbol: "kImageSpirvFs" },
+];
+
+/** DXIL programs: HLSL entry point, stage and the symbol to emit. */
+const DXIL_PROGRAMS = [
+  { target: "vs_6_0", entry: "vs_main", symbol: "kFillDxilVs" },
+  { target: "ps_6_0", entry: "fs_main", symbol: "kFillDxilFs" },
+  { target: "vs_6_0", entry: "vs_text", symbol: "kTextDxilVs" },
+  { target: "ps_6_0", entry: "fs_text", symbol: "kTextDxilFs" },
+  { target: "ps_6_0", entry: "fs_image", symbol: "kImageDxilFs" },
+];
+
+function fail(message) {
+  console.error(`xbintsc: ${message}`);
+  process.exit(1);
+}
+
+/** Newest version-suffixed directory under `base`, or undefined. */
+function newestVersionDir(base, isVersion) {
+  if (!existsSync(base)) return undefined;
+  const versions = readdirSync(base)
+    .filter(isVersion)
+    .sort((a, b) => {
+      const pa = a.split(".").map(Number);
+      const pb = b.split(".").map(Number);
+      for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0) return diff;
+      }
+      return 0;
+    })
+    .reverse();
+  return { base, versions };
+}
+
+/** Locate `glslc`: the explicit override, then the newest installed Vulkan SDK. */
+function findGlslc() {
+  if (process.env.xbintsc_GLSLC) return process.env.xbintsc_GLSLC;
+  const found = newestVersionDir("C:\\VulkanSDK", (name) => /^\d+\.\d+\.\d+\.\d+$/.test(name));
+  if (!found) return undefined;
+  for (const version of found.versions) {
+    const bin = join(found.base, version, "Bin");
+    for (const name of ["glslc.exe", "glslc"]) {
+      if (existsSync(join(bin, name))) return join(bin, name);
+    }
+  }
+  return undefined;
+}
+
+/** Locate `dxc`: the explicit override, then the newest Windows SDK. */
+function findDxc() {
+  if (process.env.xbintsc_DXC) return process.env.xbintsc_DXC;
+  const found = newestVersionDir("C:\\Program Files (x86)\\Windows Kits\\10\\bin", (name) =>
+    /^\d+\.\d+\.\d+\.\d+$/.test(name),
+  );
+  if (!found) return undefined;
+  for (const version of found.versions) {
+    for (const arch of ["x64", "arm64"]) {
+      const candidate = join(found.base, version, arch, "dxc.exe");
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return undefined;
+}
+
+/** Compile `args` with `tool`, failing with its output on a non-zero exit. */
+function compile(tool, args, label) {
+  const result = spawnSync(tool, args, { encoding: "utf8" });
+  if (result.status !== 0) {
+    fail(`${label} failed:\n${result.stderr ?? ""}${result.stdout ?? ""}`);
+  }
+}
+
+/** Render one blob as a C++ array initializer, 16 bytes per line. */
+function renderArray(symbol, bytes) {
+  const lines = [];
+  for (let i = 0; i < bytes.length; i += 16) {
+    lines.push("  " + Array.from(bytes.subarray(i, i + 16)).join(", ") + ",");
+  }
+  return [
+    `inline constexpr unsigned char ${symbol}[] = {`,
+    ...lines,
+    "};",
+    `inline constexpr size_t ${symbol}Size = sizeof(${symbol});`,
+  ].join("\n");
+}
+
+mkdirSync(scratch, { recursive: true });
+
+const blobs = [];
+
+const glslc = findGlslc();
+if (glslc === undefined) {
+  fail(
+    "no glslc found; install the Vulkan SDK (https://vulkan.lunarg.com) or set " +
+      `xbintsc_GLSLC.\nThe committed ${header} was not regenerated.`,
+  );
+}
+for (const program of SPIRV_PROGRAMS) {
+  const output = join(scratch, `${program.symbol}.spv`);
+  compile(
+    glslc,
+    ["-c", join(glslDir, program.source), "-o", output],
+    `glslc ${program.source}`,
+  );
+  blobs.push({ symbol: program.symbol, bytes: readFileSync(output) });
+}
+
+const dxc = findDxc();
+if (dxc === undefined) {
+  fail(
+    "no dxc found; install the Windows SDK or set xbintsc_DXC.\n" +
+      `The committed ${header} was not regenerated.`,
+  );
+}
+for (const program of DXIL_PROGRAMS) {
+  const output = join(scratch, `${program.symbol}.dxil`);
+  compile(
+    dxc,
+    ["-T", program.target, "-E", program.entry, "-Fo", output, hlsl],
+    `dxc ${program.target} ${program.entry}`,
+  );
+  blobs.push({ symbol: program.symbol, bytes: readFileSync(output) });
+}
+
+rmSync(scratch, { recursive: true, force: true });
+
+const generated = [
+  "/*",
+  " * Generated by `scripts/build-gui-shaders.mjs` — do not edit.",
+  " *",
+  " * SPIR-V blobs (Vulkan) compiled from `runtime/ext_gui/spirv/` with glslc, and",
+  " * DXIL blobs (Direct3D 12) compiled from `runtime/ext_gui/shaders.hlsl` with dxc.",
+  " * The Metal path uses the MSL literals in `renderer_shaders.h` directly.",
+  " */",
+  "#ifndef XT_GUI_RENDERER_SHADERS_DATA_H",
+  "#define XT_GUI_RENDERER_SHADERS_DATA_H",
+  "",
+  "#include <stddef.h>",
+  "",
+  ...blobs.map((blob) => renderArray(blob.symbol, blob.bytes)),
+  "",
+  "#endif /* XT_GUI_RENDERER_SHADERS_DATA_H */",
+  "",
+].join("\n");
+
+if (process.argv.includes("--check")) {
+  const current = existsSync(header) ? readFileSync(header, "utf8") : "";
+  if (current !== generated) {
+    fail(`${header} is out of date; run \`node scripts/build-gui-shaders.mjs\``);
+  }
+  console.log(`xbintsc: ${header} is up to date`);
+} else {
+  writeFileSync(header, generated);
+  const total = blobs.reduce((sum, blob) => sum + blob.bytes.length, 0);
+  console.log(`xbintsc: wrote ${header} (${blobs.length} blobs, ${total} bytes)`);
+}

package/scripts/build-gui.ts

@@ -53,6 +53,32 @@ const isWindows = process.platform === "win32";
 const objectSuffix = isWindows ? ".obj" : ".o";
 const output = join(outDir, isWindows ? "gui.lib" : "gui.a");
 
+/* CMake generator and ABI settings used for every vendored library. Ninja is
+ * selected on Windows because the Visual Studio generator imports the
+ * machine-wide MSBuild/vcpkg integration, whose `LIBPATH` shadows the Windows
+ * SDK and makes the compiler probe fail with
+ * `LNK1104: cannot open file 'ucrtd.lib'`.
+ *
+ * `CMAKE_MSVC_RUNTIME_LIBRARY` is pinned to the *static* CRT (`MultiThreaded`),
+ * which is clang's Windows default (`-defaultlib:libcmt`) and what xbintsc uses
+ * for its own runtime objects. Building the vendored libraries against the DLL
+ * CRT instead fails the final link with
+ * `LNK2038: mismatch detected for 'RuntimeLibrary'`. The variable only takes
+ * effect when policy CMP0091 is NEW, but FreeType and HarfBuzz declare
+ * `cmake_minimum_required` below 3.15, which defaults the policy to OLD and
+ * silently ignores it — hence `CMAKE_POLICY_DEFAULT_CMP0091`. The C/C++ compilers
+ * are pinned to the same clang the engine is compiled with, so every object in
+ * `gui.a` shares one ABI and optimization behaviour. */
+const cmakeGeneratorArgs: readonly string[] = isWindows
+  ? [
+      "-G", "Ninja",
+      "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded",
+      "-DCMAKE_POLICY_DEFAULT_CMP0091=NEW",
+      "-DCMAKE_C_COMPILER=clang",
+      "-DCMAKE_CXX_COMPILER=clang++",
+    ]
+  : [];
+
 const SDL_TAG = process.env.SDL3_TAG || "release-3.2.10";
 const FREETYPE_VERSION = process.env.FREETYPE_VERSION || "2.13.3";
 const HARFBUZZ_VERSION = process.env.HARFBUZZ_VERSION || "10.1.0";
@@ -178,6 +204,7 @@ if (!existingSdlArchive) {
   const configureArgs = [
     "-S", sdlSrc,
     "-B", sdlBuild,
+    ...cmakeGeneratorArgs,
     "-DCMAKE_BUILD_TYPE=Release",
     "-DSDL_SHARED=OFF",
     "-DSDL_STATIC=ON",
@@ -220,6 +247,7 @@ if (!existsSync(freetypeArchive() ?? "")) {
   run(cmake, [
     "-S", freetypeSrc,
     "-B", freetypeBuild,
+    ...cmakeGeneratorArgs,
     "-DCMAKE_BUILD_TYPE=Release",
     "-DBUILD_SHARED_LIBS=OFF",
     /* We only need TrueType/OpenType outlines; skip the optional codecs. */
@@ -240,6 +268,7 @@ if (!existsSync(harfbuzzArchive() ?? "")) {
   run(cmake, [
     "-S", harfbuzzSrc,
     "-B", harfbuzzBuild,
+    ...cmakeGeneratorArgs,
     "-DCMAKE_BUILD_TYPE=Release",
     "-DBUILD_SHARED_LIBS=OFF",
     "-DHB_BUILD_UTILS=OFF",
@@ -272,6 +301,12 @@ const sources = readdirSync(engineDir)
 
 const objects: string[] = [];
 const cxxFlags = ["-std=c++17", "-O2", "-Wall", "-Wextra", ...includeFlags];
+/* The engine is C++ and the MSVC C++ runtime must match the static C CRT that
+ * clang links by default, so let every engine object record `libcpmt` as a
+ * default library. The extension itself only contributes the DLL import library
+ * (`-lmsvcprt`, `src/extensions/gui/index.ts`), which is inconsistent with that
+ * CRT and makes the final link fail with `LNK2038`/unresolved `__imp_*`. */
+if (isWindows) cxxFlags.push("-Xclang", "--dependent-lib=libcpmt");
 /* The MSVC ABI rejects `-fPIC`; position independence is the default elsewhere. */
 if (!isWindows) cxxFlags.splice(3, 0, "-fPIC");
 for (const source of sources) {

package/scripts/check-file-length.ts

@@ -38,6 +38,10 @@ const IGNORED_DIRECTORIES = new Set([
 /** Vendored third-party sources that ship verbatim and are not ours to split. */
 const VENDORED_FILES = new Set([join("runtime", "ext_gui", "stb_image.h")]);
 
+/** Machine-generated files: they are reproduced from their sources by a script,
+ * so their size is not a sign of a module that needs splitting. */
+const GENERATED_FILES = new Set([join("runtime", "ext_gui", "renderer_shaders_data.h")]);
+
 interface Offense {
   file: string;
   lines: number;
@@ -65,7 +69,7 @@ function collect(dir: string, offenses: Offense[]): void {
     const dot = entry.name.lastIndexOf(".");
     if (dot < 0 || !CODE_EXTENSIONS.has(entry.name.slice(dot))) continue;
     const file = relative(root, full);
-    if (VENDORED_FILES.has(file)) continue;
+    if (VENDORED_FILES.has(file) || GENERATED_FILES.has(file)) continue;
     const lines = countLines(full);
     if (lines > MAX_LINES) offenses.push({ file, lines });
   }