xbintsc 0.3.16 → 0.3.25

package/runtime/ext_gui/dom_api.h

@@ -0,0 +1,12 @@
+/*
+ * xbintsc GUI engine — DOM object model entry points.
+ *
+ * The implementation lives in `dom_api.cpp`; this header only pulls in the
+ * shared engine definitions so translation units can include either one.
+ */
+#ifndef XT_GUI_DOM_API_H
+#define XT_GUI_DOM_API_H
+
+#include "gui_engine.h"
+
+#endif /* XT_GUI_DOM_API_H */

package/runtime/ext_gui/gui.cpp

@@ -89,6 +89,9 @@ void xt_gui_quit_window(XtGuiWindow *win) {
   if (win == NULL || !win->open) return;
   win->open = 0;
   xt_gui_emit(win, "close");
+  win->animation_frames.clear();
+  xt_gui_handles_reset(win);
+  win->document_object = XT_UNDEFINED;
   win->document.reset();
   win->html.clear();
   if (g_device != NULL) {
@@ -111,6 +114,19 @@ void xt_gui_window_viewport(XtGuiWindow *win, float *width, float *height) {
   if (height != NULL) *height = (float)h;
 }
 
+void xt_gui_flush_dom(XtGuiWindow *win) {
+  if (win == NULL || win->document == nullptr) return;
+  bool mutated = win->struct_dirty != 0;
+  win->struct_dirty = 0;
+  if (win->document->takeDirty()) mutated = true;
+  if (!mutated) return;
+  float width = 0;
+  float height = 0;
+  xt_gui_window_viewport(win, &width, &height);
+  win->document->restyle(width, height);
+  win->geometry.dirty = 1;
+}
+
 static XtGuiWindow *xt_gui_find_by_window_id(SDL_WindowID id) {
   SDL_Window *window = SDL_GetWindowFromID(id);
   if (window == NULL) return NULL;
@@ -164,10 +180,13 @@ void xt_gui_dispatch_pointer(XtGuiWindow *win, const char *type, float x, float
                              int clicks) {
   if (win == NULL || !win->open) return;
   xt_gui_update_hover(win, x, y);
+  const xtgui::Node *node = xt_gui_hit_node(win, x, y);
   if (strcmp(type, "mousedown") == 0 && win->document != nullptr) {
-    if (win->document->setFocus(xt_gui_hit_node(win, x, y))) win->geometry.dirty = 1;
+    if (win->document->setFocus(node)) win->geometry.dirty = 1;
   }
-  xt_gui_emit_payload(win, type, xt_gui_pointer_payload(type, win, x, y, button, clicks));
+  xt_value payload = xt_gui_pointer_payload(type, win, x, y, button, clicks);
+  if (node != nullptr) xt_gui_emit_dom_event(win, type, node, payload);
+  xt_gui_emit_payload(win, type, payload);
 }
 
 void xt_gui_dispatch_wheel(XtGuiWindow *win, float x, float y, float delta_x, float delta_y) {
@@ -175,6 +194,8 @@ void xt_gui_dispatch_wheel(XtGuiWindow *win, float x, float y, float delta_x, fl
   xt_value payload = xt_gui_pointer_payload("wheel", win, x, y, -1, 0);
   xt_object_set(payload, xt_string_from_cstr("deltaX"), xt_number(delta_x));
   xt_object_set(payload, xt_string_from_cstr("deltaY"), xt_number(delta_y));
+  const xtgui::Node *node = xt_gui_hit_node(win, x, y);
+  if (node != nullptr) xt_gui_emit_dom_event(win, "wheel", node, payload);
   xt_gui_emit_payload(win, "wheel", payload);
 }
 
@@ -194,7 +215,10 @@ static xt_value xt_gui_key_payload(const char *type, const char *key, const char
 
 void xt_gui_dispatch_key(XtGuiWindow *win, const char *type, const char *key, const char *code) {
   if (win == NULL || !win->open) return;
-  xt_gui_emit_payload(win, type, xt_gui_key_payload(type, key, code, false, false, false, false, false));
+  xt_value payload = xt_gui_key_payload(type, key, code, false, false, false, false, false);
+  const xtgui::Node *node = win->document != nullptr ? win->document->focus() : nullptr;
+  if (node != nullptr) xt_gui_emit_dom_event(win, type, node, payload);
+  xt_gui_emit_payload(win, type, payload);
 }
 
 static void xt_gui_handle_event(const SDL_Event *event) {
@@ -265,6 +289,19 @@ static void xt_gui_handle_event(const SDL_Event *event) {
 
 /* -- rendering ------------------------------------------------------------ */
 
+void xt_gui_run_animation_frames(XtGuiWindow *win, double timestamp_ms) {
+  if (win == NULL || win->animation_frames.empty()) return;
+  /* Swap the queue out first: a callback that calls requestAnimationFrame
+   * again schedules for the *next* frame, not this one. */
+  std::vector<XtGuiAnimationFrame> frames;
+  frames.swap(win->animation_frames);
+  for (const XtGuiAnimationFrame &frame : frames) {
+    if (!win->open) break;
+    xt_value arg = xt_number(timestamp_ms);
+    xt_call_with_this(frame.fn, win->object, 1, &arg);
+  }
+}
+
 void xt_gui_render_window(XtGuiWindow *win) {
   if (win == NULL || !win->open || win->window == NULL || g_device == NULL) return;
   float viewport_width = 0;
@@ -275,8 +312,15 @@ void xt_gui_render_window(XtGuiWindow *win) {
   double now = (double)SDL_GetTicks();
   double delta = win->last_frame_ms > 0.0 ? now - win->last_frame_ms : 0.0;
   win->last_frame_ms = now;
+  /* Animation-frame callbacks run before layout, so any DOM mutation they make
+   * is picked up by this same frame. */
+  xt_gui_run_animation_frames(win, now);
   if (win->document != nullptr && win->document->advance(delta)) win->geometry.dirty = 1;
 
+  /* A DOM mutation from a handler invalidates the tree: restyle/relayout
+   * before (re)building the geometry. */
+  xt_gui_flush_dom(win);
+
   /* Rebuild the geometry only when the document or viewport changed. */
   bool can_paint = xt_gui_renderer_ensure(g_device, win->window);
   if (can_paint && win->geometry.dirty && win->document != nullptr) {
@@ -378,6 +422,8 @@ extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
   record->text_geometry = XtGuiGeometry();
   record->image_geometry = XtGuiGeometry();
   record->last_frame_ms = 0.0;
+  record->animation_frames.clear();
+  record->next_animation_frame_id = 1;
   record->background[0] = 0.08f;
   record->background[1] = 0.09f;
   record->background[2] = 0.11f;

package/runtime/ext_gui/gui_engine.h

@@ -22,6 +22,8 @@ extern "C" {
 xt_value xt_gui_create_window(int32_t argc, xt_value *argv);
 xt_value xt_gui_run(int32_t argc, xt_value *argv);
 xt_value xt_gui_quit(int32_t argc, xt_value *argv);
+/** `__registerScript(id, fn)`: record an AOT-compiled `<script>` body. */
+xt_value xt_register_script(int32_t argc, xt_value *argv);
 
 #ifdef __cplusplus
 } /* extern "C" */
@@ -30,10 +32,26 @@ xt_value xt_gui_quit(int32_t argc, xt_value *argv);
 
 #include <memory>
 #include <string>
+#include <unordered_map>
+#include <vector>
 
 #include "document.h"
 #include "renderer.h"
 
+/** One element-level event listener registered through `addEventListener`. */
+struct XtGuiNodeListener {
+  std::string type;
+  xt_value fn;
+  bool once;
+  bool capture;
+};
+
+/** One pending `requestAnimationFrame` callback. */
+struct XtGuiAnimationFrame {
+  int id;
+  xt_value fn;
+};
+
 /* One live window. `object` is the JavaScript-visible handle; the record is
  * addressed from it through the hidden `__xt_gui_index` property. */
 struct XtGuiWindow {
@@ -50,10 +68,43 @@ struct XtGuiWindow {
   float background[4];
   int width;
   int height;
+
+  /* -- DOM object model (element handles + events) ----------------------- */
+  /** `document` handle for this window (lazily created). */
+  xt_value document_object = XT_UNDEFINED;
+  /** Bumped on every `loadHTML`; stale handles no-op. */
+  double doc_generation = 1.0;
+  /** Node -> table index / cached handle, so identity is stable. */
+  std::vector<xtgui::Node *> node_order;
+  std::unordered_map<const xtgui::Node *, int> node_index;
+  std::unordered_map<const xtgui::Node *, xt_value> node_handles;
+  /** Element-level listeners, keyed by node. */
+  std::unordered_map<const xtgui::Node *, std::vector<XtGuiNodeListener>> node_listeners;
+  /** Set by a DOM mutation; consumed by the frame loop before repainting. */
+  int struct_dirty = 0;
+  /** Callbacks queued for the next frame, plus the id counter. */
+  std::vector<XtGuiAnimationFrame> animation_frames;
+  int next_animation_frame_id = 1;
 };
 
 /** Resolve a window handle (`this`) to its record, or NULL for a foreign value. */
 XtGuiWindow *xt_gui_window_from_this(xt_value thisValue);
+/** The `document` handle for `win` (created on first use). */
+xt_value xt_gui_document_handle(XtGuiWindow *win);
+/** Node handle for `node` (created and cached on first use). */
+xt_value xt_gui_node_handle(XtGuiWindow *win, const xtgui::Node *node);
+/** Drop every cached handle/listener and bump the document generation. */
+void xt_gui_handles_reset(XtGuiWindow *win);
+/** Deliver `type` to element listeners along the propagation path. */
+void xt_gui_emit_dom_event(XtGuiWindow *win, const char *type, const xtgui::Node *target,
+                           xt_value legacy_payload);
+/** Synthesise a DOM event whose target is `target` (used by element.click()). */
+void xt_gui_dispatch_to_node(XtGuiWindow *win, const xtgui::Node *target, const char *type);
+/** Apply any pending DOM mutation (restyle/relayout) before a synchronous read. */
+void xt_gui_flush_dom(XtGuiWindow *win);
+/** Run every registered `<script data-xt-id>` body found in the document, in
+ * document order, passing `(windowHandle, documentHandle)`. */
+void xt_gui_run_scripts(XtGuiWindow *win);
 /** Shared prototype carrying the window methods. */
 xt_value xt_gui_window_proto(void);
 /** Release GPU claim + destroy the window and mark the record closed. */
@@ -64,6 +115,9 @@ void xt_gui_emit(XtGuiWindow *win, const char *event);
 void xt_gui_emit_payload(XtGuiWindow *win, const char *event, xt_value payload);
 /** Acquire a swapchain frame for `win` and clear it (placeholder paint). */
 void xt_gui_render_window(XtGuiWindow *win);
+/** Run every callback queued with `requestAnimationFrame` for the frame at
+ * `timestamp_ms`, then clear the queue. */
+void xt_gui_run_animation_frames(XtGuiWindow *win, double timestamp_ms);
 /** Current logical window size (CSS viewport), in pixels. */
 void xt_gui_window_viewport(XtGuiWindow *win, float *width, float *height);
 /** CSS-like descriptor of the deepest element at (x, y), or `""` (test/debug). */

package/runtime/ext_gui/script.cpp

@@ -0,0 +1,63 @@
+/*
+ * xbintsc GUI engine — AOT `<script>` registry.
+ *
+ * xbintsc has no runtime interpreter, so `<script>` bodies are compiled ahead
+ * of time. The `.html` asset loader (see `src/extensions/gui/html.ts`) extracts
+ * each inline body, wraps it in a function `(window, document) => { ... }` and
+ * calls the `__registerScript(id, fn)` builtin at module initialization. This
+ * file keeps that registry and runs the matching functions once the document
+ * has been parsed.
+ */
+
+#include "gui_engine.h"
+
+#include <string>
+#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). */
+static std::unordered_map<std::string, xt_value> &script_registry() {
+  static std::unordered_map<std::string, xt_value> registry;
+  return registry;
+}
+
+extern "C" xt_value xt_register_script(int32_t argc, xt_value *argv) {
+  if (argc >= 2) {
+    xt_value id_value = xt_to_string(xt_arg(argc, argv, 0));
+    const char *id = xt_string_data(id_value);
+    xt_value fn = xt_arg(argc, argv, 1);
+    if (id != nullptr && XT_IS_FUNCTION(fn)) {
+      script_registry()[std::string(id)] = fn;
+    }
+  }
+  return XT_UNDEFINED;
+}
+
+/** 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;
+  if (node->isElement() && node->isTag("script")) {
+    const std::string *id = node->attr("data-xt-id");
+    if (id != nullptr && !id->empty()) ids.push_back(*id);
+    return;
+  }
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    collect_script_ids(child.get(), ids);
+  }
+}
+
+void xt_gui_run_scripts(XtGuiWindow *win) {
+  if (win == nullptr || win->document == nullptr) return;
+  std::vector<std::string> ids;
+  collect_script_ids(win->document->root(), ids);
+  if (ids.empty()) return;
+  xt_value window_handle = win->object;
+  xt_value document_handle = xt_gui_document_handle(win);
+  for (const std::string &id : ids) {
+    auto it = script_registry().find(id);
+    if (it == script_registry().end()) continue;
+    xt_value args[2] = {window_handle, document_handle};
+    xt_call_with_this(it->second, XT_UNDEFINED, 2, args);
+  }
+}

package/runtime/ext_gui/window.cpp

@@ -10,6 +10,8 @@
 
 #include "gui_engine.h"
 
+#include <algorithm>
+
 #include "paint.h"
 #include "text.h"
 
@@ -48,16 +50,23 @@ static xt_value win_load_html(xt_value self, xt_value env, int32_t argc, xt_valu
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win != nullptr) {
     win->html = html;
+    /* Fresh document: invalidate every previously handed-out handle. */
+    xt_gui_handles_reset(win);
     win->document = std::make_unique<xtgui::XtDocument>();
     float width = 0;
     float height = 0;
     xt_gui_window_viewport(win, &width, &height);
     win->document->load(html, width, height);
     win->geometry.dirty = 1;
+    /* Run the AOT-compiled `<script>` bodies now that the tree is parsed, so
+     * `document.getElementById(...)` resolves, then settle the first layout. */
+    xt_gui_run_scripts(win);
+    xt_gui_flush_dom(win);
   }
   xt_object_set(self, xt_string_from_cstr("__xt_gui_html"), xt_string_from_cstr(html.c_str()));
   /* Painting the document is milestone M3b+; the parsed tree and computed
    * styles are available now (see `computedStyle`). */
+  xt_gui_emit(win, "DOMContentLoaded");
   xt_gui_emit(win, "load");
   return XT_UNDEFINED;
 }
@@ -69,12 +78,21 @@ static xt_value win_get_html(xt_value self, xt_value env, int32_t argc, xt_value
   return xt_object_get_cstr(self, "__xt_gui_html");
 }
 
+/** The `document` handle for this window (created on first access). */
+static xt_value win_document_get(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_gui_document_handle(xt_gui_window_from_this(self));
+}
+
 /** Diagnostic/test hook: computed value of `property` for the first match of
  * `selector`, or an empty string. */
 static xt_value win_computed_style(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr || argc < 2) return xt_string_from_cstr("");
+  xt_gui_flush_dom(win);
   xt_value selectorValue = xt_to_string(xt_arg(argc, argv, 0));
   xt_value propertyValue = xt_to_string(xt_arg(argc, argv, 1));
   const char *selector = xt_string_data(selectorValue);
@@ -95,6 +113,7 @@ static xt_value win_document_tree(xt_value self, xt_value env, int32_t argc, xt_
   (void)argv;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr) return xt_string_from_cstr("");
+  xt_gui_flush_dom(win);
   std::string text = win->document->toDebugString();
   return xt_string_from_cstr(text.c_str());
 }
@@ -104,6 +123,7 @@ static xt_value win_query_count(xt_value self, xt_value env, int32_t argc, xt_va
   (void)env;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr || argc < 1) return xt_number(0);
+  xt_gui_flush_dom(win);
   xt_value selectorValue = xt_to_string(xt_arg(argc, argv, 0));
   const char *selector = xt_string_data(selectorValue);
   if (selector == nullptr) return xt_number(0);
@@ -116,6 +136,7 @@ static xt_value win_get_bounding_rect(xt_value self, xt_value env, int32_t argc,
   (void)env;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr || argc < 1) return XT_UNDEFINED;
+  xt_gui_flush_dom(win);
   xt_value selectorValue = xt_to_string(xt_arg(argc, argv, 0));
   const char *selector = xt_string_data(selectorValue);
   if (selector == nullptr) return XT_UNDEFINED;
@@ -138,6 +159,7 @@ static xt_value win_layout_tree(xt_value self, xt_value env, int32_t argc, xt_va
   (void)argv;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr) return xt_string_from_cstr("");
+  xt_gui_flush_dom(win);
   std::string text = win->document->layout().dump();
   return xt_string_from_cstr(text.c_str());
 }
@@ -169,6 +191,7 @@ static xt_value win_paint_list(xt_value self, xt_value env, int32_t argc, xt_val
   (void)argv;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr) return xt_string_from_cstr("");
+  xt_gui_flush_dom(win);
   xtgui::DisplayList list;
   xtgui::xt_paint_build(win->document->layout().root(), list);
   std::string text = list.dump();
@@ -182,6 +205,7 @@ static xt_value win_paint_count(xt_value self, xt_value env, int32_t argc, xt_va
   (void)argv;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr) return xt_number(0);
+  xt_gui_flush_dom(win);
   xtgui::DisplayList list;
   xtgui::xt_paint_build(win->document->layout().root(), list);
   return xt_number((double)list.rects.size());
@@ -259,6 +283,34 @@ 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;
 }
 
+/** `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,
+                                            xt_value *argv) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == NULL || !win->open) return xt_number(0);
+  xt_value fn = xt_arg(argc, argv, 0);
+  if (!XT_IS_FUNCTION(fn)) return xt_number(0);
+  int id = win->next_animation_frame_id++;
+  win->animation_frames.push_back(XtGuiAnimationFrame{id, fn});
+  return xt_number((double)id);
+}
+
+/** `cancelAnimationFrame(id)` drops a callback queued for the next frame. */
+static xt_value win_cancel_animation_frame(xt_value self, xt_value env, int32_t argc,
+                                           xt_value *argv) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == NULL || argc < 1) return XT_UNDEFINED;
+  int id = (int)xt_to_number(xt_arg(argc, argv, 0));
+  std::vector<XtGuiAnimationFrame> &frames = win->animation_frames;
+  frames.erase(std::remove_if(frames.begin(), frames.end(),
+                              [id](const XtGuiAnimationFrame &frame) { return frame.id == id; }),
+               frames.end());
+  return XT_UNDEFINED;
+}
+
 static xt_value win_on(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
   (void)env;
   if (argc >= 2) {
@@ -314,6 +366,7 @@ static xt_value win_hit_test(xt_value self, xt_value env, int32_t argc, xt_value
   (void)env;
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr || argc < 2) return xt_string_from_cstr("");
+  xt_gui_flush_dom(win);
   float x = (float)xt_to_number(xt_arg(argc, argv, 0));
   float y = (float)xt_to_number(xt_arg(argc, argv, 1));
   std::string target = xt_gui_hit_test(win, x, y);
@@ -376,10 +429,15 @@ static void define_method(xt_value proto, const char *name, void *fn) {
   xt_object_set(proto, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
 }
 
+static void define_getter(xt_value proto, const char *name, void *fn) {
+  xt_object_define_getter(proto, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
 xt_value xt_gui_window_proto(void) {
   if (XT_IS_OBJECT(g_window_proto)) return g_window_proto;
   xt_value proto = xt_object_new();
   define_method(proto, "setTitle", (void *)win_set_title);
+  define_getter(proto, "document", (void *)win_document_get);
   define_method(proto, "setSize", (void *)win_set_size);
   define_method(proto, "loadHTML", (void *)win_load_html);
   define_method(proto, "getHTML", (void *)win_get_html);
@@ -396,6 +454,8 @@ 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, "requestAnimationFrame", (void *)win_request_animation_frame);
+  define_method(proto, "cancelAnimationFrame", (void *)win_cancel_animation_frame);
   define_method(proto, "on", (void *)win_on);
   define_method(proto, "off", (void *)win_off);
   define_method(proto, "hitTest", (void *)win_hit_test);

package/src/driver/bundler/graph.ts

@@ -4,12 +4,13 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, extname } from "node:path";
 import { SyntaxKind, type ExportDeclaration, type ImportDeclaration, type Statement } from "../../ast/nodes.js";
 import { bind } from "../../binder/binder.js";
 import { DiagnosticBag, DiagnosticCode } from "../../diagnostics/diagnostic.js";
 import { SourceFile } from "../../diagnostics/source.js";
 import { Parser } from "../../parser/parser.js";
+import type { AssetLoader } from "../../extensions/registry.js";
 import { classifyDependency } from "./resolve.js";
 import type { ModuleRecord } from "./types.js";
 
@@ -29,6 +30,7 @@ export function loadGraph(
   entryPath: string,
   diagnostics: DiagnosticBag,
   externalSpecifiers: ReadonlySet<string>,
+  assetLoaders: Readonly<Record<string, AssetLoader>> = {},
 ): ModuleRecord[] | undefined {
   const records = new Map<string, ModuleRecord>();
   const order: ModuleRecord[] = [];
@@ -50,7 +52,24 @@ export function loadGraph(
       return undefined;
     }
     visiting.add(path);
-    const text = readFileSync(path, "utf8");
+    const raw = readFileSync(path, "utf8");
+    /* An extension may rewrite an imported asset (e.g. `.html`) into a TS
+     * module before it is parsed. The core only sees the transformed text. */
+    const loader = assetLoaders[extname(path).toLowerCase()];
+    let text = raw;
+    if (loader) {
+      try {
+        text = loader(path, raw).moduleSource;
+      } catch (error) {
+        diagnostics.error(
+          DiagnosticCode.CodegenError,
+          error instanceof Error ? error.message : String(error),
+        );
+        failed = true;
+        visiting.delete(path);
+        return undefined;
+      }
+    }
     const file = new SourceFile(path, text);
     const parser = new Parser(file, diagnostics);
     const sourceFile = parser.parseSourceFile();

package/src/driver/bundler/merge.ts

@@ -27,6 +27,7 @@ import {
 import type { BindingName } from "../../ast/declarations.js";
 import { SymbolKind } from "../../binder/binder.js";
 import type { DiagnosticBag } from "../../diagnostics/diagnostic.js";
+import type { AssetLoader } from "../../extensions/registry.js";
 import { loadGraph } from "./graph.js";
 import { classifyDependency } from "./resolve.js";
 import {
@@ -43,8 +44,9 @@ export function bundleModules(
   entryPath: string,
   diagnostics: DiagnosticBag,
   externalSpecifiers: ReadonlySet<string> = new Set(),
+  assetLoaders: Readonly<Record<string, AssetLoader>> = {},
 ): BundleResult | undefined {
-  const records = loadGraph(entryPath, diagnostics, externalSpecifiers);
+  const records = loadGraph(entryPath, diagnostics, externalSpecifiers, assetLoaders);
   if (!records) return undefined;
 
   const byPath = new Map(records.map((record) => [record.path, record]));

package/src/driver/compiler.ts

@@ -109,7 +109,7 @@ export function compileEntry(entryPath: string, extensions?: ExtensionRegistry):
       statement.kind === SyntaxKind.ExportAssignment,
   );
   if (isModule) {
-    const bundled = bundleModules(absoluteEntry, diagnostics, externalModuleSpecifiers(registry));
+    const bundled = bundleModules(absoluteEntry, diagnostics, externalModuleSpecifiers(registry), registry.assetLoaders());
     if (bundled) sourceFile = bundled.sourceFile;
   }
   const { ir } = generate(sourceFile, diagnostics, {
@@ -185,7 +185,7 @@ export function build(entryPath: string, options: BuildOptions = {}): BuildResul
   );
   let cacheText = sourceText;
   if (isModule) {
-    const bundled = bundleModules(absoluteEntry, diagnostics, externalModuleSpecifiers(registry));
+    const bundled = bundleModules(absoluteEntry, diagnostics, externalModuleSpecifiers(registry), registry.assetLoaders());
     if (bundled) {
       sourceFile = bundled.sourceFile;
       cacheText = bundled.text;