@emkodev/emroute 1.6.6-beta.4 → 1.7.0

package/server/build.util.ts

@@ -5,16 +5,24 @@
  * separate concern from storage. Call `buildClientBundles()` before
  * `createEmrouteServer()` to produce emroute.js + app.js.
  *
- * Requires esbuild as a devDependency in the consumer project.
+ * Route tree and widget manifest are fetched as JSON at boot time by
+ * `bootEmrouteApp()` — no longer compiled into app.js.
+ *
+ * Per-file module merging: each .ts page/widget is transpiled to .js with
+ * companion files (.html, .md, .css) inlined as `export const __files`.
+ * The browser lazy-loads these individual .js files — no bundler needed.
  */
 
 import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { resolve } from 'node:path';
 import type { Runtime } from '../runtime/abstract.runtime.ts';
-import { DEFAULT_ROUTES_DIR, DEFAULT_WIDGETS_DIR } from '../runtime/abstract.runtime.ts';
-import { createManifestPlugin } from './esbuild-manifest.plugin.ts';
-import { createRuntimeLoaderPlugin } from '../runtime/bun/esbuild-runtime-loader.plugin.ts';
+import {
+  ROUTES_MANIFEST_PATH,
+  WIDGETS_MANIFEST_PATH,
+} from '../runtime/abstract.runtime.ts';
+import type { RouteNode } from '../src/type/route-tree.type.ts';
+import type { WidgetManifestEntry } from '../src/type/widget.type.ts';
 import { generateMainTs } from './codegen.util.ts';
 import type { SpaMode } from '../src/type/widget.type.ts';
 
@@ -48,8 +56,10 @@ const DEFAULT_BUNDLE_PATHS = { emroute: '/emroute.js', app: '/app.js' };
  * Build client bundles and write them into the runtime.
  *
  * Produces:
+ * - Merged .js modules — each .ts page/widget transpiled with companions inlined
+ * - Updated manifests — route tree and widget manifest reference .js paths
  * - emroute.js — pre-built from dist/ (no esbuild needed for this)
- * - app.js — consumer entry point with routeTree, FetchRuntime, createEmrouteApp
+ * - app.js — consumer entry point (esbuild only touches consumer code)
  * - index.html — shell with import map + script tags (if not already present)
  */
 export async function buildClientBundles(options: BuildOptions): Promise<void> {
@@ -58,26 +68,25 @@ export async function buildClientBundles(options: BuildOptions): Promise<void> {
 
   const paths = options.bundlePaths ?? DEFAULT_BUNDLE_PATHS;
 
+  // Merge .ts modules → .js with inlined companions, update manifests
+  await mergeModules(runtime);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const esbuild = await loadEsbuild() as any;
+
   // Copy pre-built emroute.js from the package dist/
   const consumerRequire = createRequire(root + '/');
   const emrouteJsPath = resolvePrebuiltBundle(consumerRequire);
   const emrouteJs = await readFile(emrouteJsPath);
   await runtime.command(paths.emroute, { body: emrouteJs });
 
-  // App bundle — generate main.ts if absent, virtual plugin resolves manifests
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const esbuild = await loadEsbuild() as any;
+  // App bundle — consumer's main.ts bundled with esbuild.
   const ep = entryPoint ?? '/main.ts';
   if ((await runtime.query(ep)).status === 404) {
-    const hasRoutes = (await runtime.query((runtime.config.routesDir ?? DEFAULT_ROUTES_DIR) + '/')).status !== 404;
-    const hasWidgets = (await runtime.query((runtime.config.widgetsDir ?? DEFAULT_WIDGETS_DIR) + '/')).status !== 404;
-    const code = generateMainTs(spa, hasRoutes, hasWidgets, '@emkodev/emroute');
+    const code = generateMainTs(spa, '@emkodev/emroute');
     await runtime.command(ep, { body: code });
   }
 
-  const manifestPlugin = createManifestPlugin({ runtime, resolveDir: root });
-  const runtimeLoader = createRuntimeLoaderPlugin({ runtime, root });
-
   const result = await esbuild.build({
     bundle: true,
     write: false,
@@ -86,7 +95,6 @@ export async function buildClientBundles(options: BuildOptions): Promise<void> {
     entryPoints: [`${root}${ep}`],
     outfile: `${root}${paths.app}`,
     external: [...EMROUTE_EXTERNALS],
-    plugins: [manifestPlugin, runtimeLoader],
   });
 
   for (const file of result.outputFiles) {
@@ -97,7 +105,7 @@ export async function buildClientBundles(options: BuildOptions): Promise<void> {
   }
 
   // Write shell (index.html) if not already present
-  await writeShell(runtime, paths, ep);
+  await writeShell(runtime, paths);
 
   await esbuild.stop();
 }
@@ -125,7 +133,6 @@ function resolvePrebuiltBundle(require: NodeRequire): string {
 async function writeShell(
   runtime: Runtime,
   paths: { emroute: string; app: string },
-  entryPoint: string,
 ): Promise<void> {
   if ((await runtime.query('/index.html')).status !== 404) return;
 
@@ -135,13 +142,6 @@ async function writeShell(
   }
   const importMap = JSON.stringify({ imports }, null, 2);
 
-  const scripts = [
-    `<script type="importmap">\n${importMap}\n  </script>`,
-  ];
-  if (entryPoint) {
-    scripts.push(`<script type="module" src="${paths.app}"></script>`);
-  }
-
   const html = `<!DOCTYPE html>
 <html>
 <head>
@@ -152,13 +152,143 @@ async function writeShell(
 </head>
 <body>
   <router-slot></router-slot>
-  ${scripts.join('\n  ')}
+  <script type="importmap">
+${importMap}
+  </script>
+  <script type="module" src="${paths.app}"></script>
 </body>
 </html>`;
 
   await runtime.command('/index.html', { body: html });
 }
 
+// ── Module merging ───────────────────────────────────────────────────
+
+/** Escape backticks and ${} for safe embedding in a JS template literal. */
+function escapeTemplateLiteral(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+
+/** Convert a .ts path to .js (e.g. "routes/about.page.ts" → "routes/about.page.js"). */
+function tsToJs(path: string): string {
+  return path.replace(/\.ts$/, '.js');
+}
+
+/**
+ * Read a file from runtime as text. Returns undefined if not found.
+ */
+async function readText(runtime: Runtime, path: string): Promise<string | undefined> {
+  const abs = path.startsWith('/') ? path : '/' + path;
+  const response = await runtime.query(abs);
+  if (response.status === 404) return undefined;
+  return response.text();
+}
+
+/**
+ * Transpile a .ts module, inline companion files as `__files` export,
+ * and write the resulting .js back to the runtime.
+ *
+ * Returns the .js output path.
+ */
+async function transpileAndMerge(
+  runtime: Runtime,
+  tsPath: string,
+  companionPaths?: { html?: string; md?: string; css?: string },
+): Promise<string> {
+  const source = await readText(runtime, tsPath);
+  if (!source) throw new Error(`[emroute] Module not found: ${tsPath}`);
+
+  const js = await runtime.transpile(source);
+  const jsPath = tsToJs(tsPath);
+
+  // Read companion files and build __files export
+  const entries: string[] = [];
+  if (companionPaths) {
+    for (const [key, filePath] of Object.entries(companionPaths)) {
+      if (!filePath) continue;
+      const content = await readText(runtime, filePath);
+      if (content !== undefined) {
+        entries.push(`  ${key}: \`${escapeTemplateLiteral(content)}\``);
+      }
+    }
+  }
+
+  const merged = entries.length > 0
+    ? `${js}\nexport const __files = {\n${entries.join(',\n')}\n};\n`
+    : js;
+
+  const absJsPath = jsPath.startsWith('/') ? jsPath : '/' + jsPath;
+  await runtime.command(absJsPath, { body: merged });
+  return jsPath;
+}
+
+/**
+ * Walk the route tree and widget manifest, transpile+merge each .ts module,
+ * update the manifests to reference .js paths, and write them back.
+ */
+async function mergeModules(runtime: Runtime): Promise<void> {
+  // Read route tree
+  const routesResponse = await runtime.query(ROUTES_MANIFEST_PATH);
+  if (routesResponse.status === 404) return;
+  const routeTree: RouteNode = await routesResponse.json();
+
+  // Read widget manifest
+  const widgetsResponse = await runtime.query(WIDGETS_MANIFEST_PATH);
+  const widgetEntries: WidgetManifestEntry[] = widgetsResponse.status !== 404
+    ? await widgetsResponse.json()
+    : [];
+
+  // Merge route modules
+  async function walkRoutes(node: RouteNode): Promise<void> {
+    if (node.files?.ts) {
+      const companions = {
+        html: node.files.html,
+        md: node.files.md,
+        css: node.files.css,
+      };
+      node.files.js = await transpileAndMerge(runtime, node.files.ts, companions);
+      delete node.files.ts;
+      delete node.files.html;
+      delete node.files.md;
+      delete node.files.css;
+    }
+
+    if (node.redirect && node.redirect.endsWith('.ts')) {
+      await transpileAndMerge(runtime, node.redirect);
+      node.redirect = tsToJs(node.redirect);
+    }
+
+    if (node.errorBoundary && node.errorBoundary.endsWith('.ts')) {
+      await transpileAndMerge(runtime, node.errorBoundary);
+      node.errorBoundary = tsToJs(node.errorBoundary);
+    }
+
+    if (node.children) {
+      for (const child of Object.values(node.children)) await walkRoutes(child);
+    }
+    if (node.dynamic) await walkRoutes(node.dynamic.child);
+    if (node.wildcard) await walkRoutes(node.wildcard.child);
+  }
+
+  await walkRoutes(routeTree);
+
+  // Merge widget modules
+  for (const entry of widgetEntries) {
+    if (entry.modulePath.endsWith('.ts')) {
+      entry.modulePath = await transpileAndMerge(runtime, entry.modulePath, entry.files);
+      delete entry.files;
+    }
+  }
+
+  // Write updated manifests back
+  await runtime.command(ROUTES_MANIFEST_PATH, {
+    body: JSON.stringify(routeTree),
+  });
+  await runtime.command(WIDGETS_MANIFEST_PATH, {
+    body: JSON.stringify(widgetEntries),
+  });
+}
+
 // ── esbuild loader ────────────────────────────────────────────────────
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/server/codegen.util.ts

@@ -2,87 +2,40 @@
  * Code Generation Utilities
  *
  * Generates a default main.ts entry point for SPA bootstrapping.
- * Manifest data is resolved at bundle time via the esbuild virtual
- * manifest plugin (`emroute:routes`, `emroute:widgets`).
+ * The generated code simply calls `bootEmrouteApp()` which handles
+ * fetching manifests, creating the runtime, and wiring navigation.
  */
 
-import type { BasePath } from '../src/route/route.core.ts';
 import type { SpaMode } from '../src/type/widget.type.ts';
 
 /**
- * Generate a main.ts entry point for SPA bootstrapping.
+ * Generate a minimal main.ts entry point.
  *
- * For `root`/`only` modes: creates an EmrouteServer with FetchRuntime
- * in the browser and wires it to Navigation API via `createEmrouteApp`.
+ * For `root`/`only` modes: calls `bootEmrouteApp()` which fetches
+ * manifests as JSON, creates FetchRuntime, registers widgets lazily,
+ * and wires Navigation API.
  *
- * Imports route tree and widget manifests from virtual `emroute:` specifiers
- * that the esbuild manifest plugin resolves at bundle time.
+ * For `leaf` mode: just imports the SPA module (registers custom elements).
+ *
+ * Consumer can replace this with a hand-written main.ts that sets up
+ * MarkdownElement renderer, registers custom elements, etc.
  */
 export function generateMainTs(
   spa: SpaMode,
-  hasRoutes: boolean,
-  hasWidgets: boolean,
   importPath: string,
-  basePath?: BasePath,
 ): string {
-  const imports: string[] = [];
-  const body: string[] = [];
-
   const spaImport = `${importPath}/spa`;
 
-  if (hasWidgets) {
-    imports.push(`import { ComponentElement, WidgetRegistry } from '${spaImport}';`);
-    imports.push(`import { widgetsManifest } from 'emroute:widgets';`);
-    body.push('const widgets = new WidgetRegistry();');
-    body.push('for (const entry of widgetsManifest.widgets) {');
-    body.push(
-      '  const mod = await widgetsManifest.moduleLoaders![entry.modulePath]() as Record<string, unknown>;',
-    );
-    body.push('  for (const exp of Object.values(mod)) {');
-    body.push("    if (exp && typeof exp === 'object' && 'getData' in exp) {");
-    body.push('      widgets.add(exp as any);');
-    body.push('      ComponentElement.register(exp as any, entry.files);');
-    body.push('      break;');
-    body.push('    }');
-    body.push("    if (typeof exp === 'function' && exp.prototype?.getData) {");
-    body.push('      const instance = new (exp as new () => any)();');
-    body.push('      widgets.add(instance);');
-    body.push(
-      '      ComponentElement.registerClass(exp as new () => any, entry.name, entry.files);',
-    );
-    body.push('      break;');
-    body.push('    }');
-    body.push('  }');
-    body.push('}');
-  }
-
-  if ((spa === 'root' || spa === 'only') && hasRoutes) {
-    imports.push(`import { routeTree, moduleLoaders } from 'emroute:routes';`);
-    imports.push(`import { createEmrouteServer } from '${importPath}/server';`);
-    imports.push(`import { FetchRuntime } from '${importPath}/runtime/fetch';`);
-    imports.push(`import { createEmrouteApp } from '${spaImport}';`);
-
-    body.push('const runtime = new FetchRuntime(location.origin);');
-
-    // Merge route + widget module loaders so the browser never calls runtime.loadModule()
-    const loadersExpr = hasWidgets
-      ? '{ ...moduleLoaders, ...widgetsManifest.moduleLoaders }'
-      : 'moduleLoaders';
-
-    const configParts = ['routeTree', `moduleLoaders: ${loadersExpr}`];
-    if (hasWidgets) configParts.push('widgets');
-    if (basePath) {
-      configParts.push(`basePath: { html: '${basePath.html}', md: '${basePath.md}', app: '${basePath.app}' }`);
-    }
-    body.push(`const server = await createEmrouteServer({ ${configParts.join(', ')} }, runtime);`);
+  if (spa === 'root' || spa === 'only') {
+    return `/** Auto-generated entry point — do not edit. */
+import { bootEmrouteApp } from '${spaImport}';
 
-    const appOpts = basePath
-      ? `{ basePath: { html: '${basePath.html}', md: '${basePath.md}', app: '${basePath.app}' } }`
-      : '';
-    body.push(`await createEmrouteApp(server${appOpts ? ', ' + appOpts : ''});`);
+await bootEmrouteApp();
+`;
   }
 
-  return `/** Auto-generated entry point — do not edit. */\n${imports.join('\n')}\n\n${
-    body.join('\n')
-  }\n`;
+  // leaf mode — just import spa module to register custom elements
+  return `/** Auto-generated entry point — do not edit. */
+import '${spaImport}';
+`;
 }

package/src/element/component.element.ts

@@ -27,6 +27,12 @@ export class ComponentElement<TParams, TData> extends HTMLElementBase {
   /** Shared file content cache — deduplicates fetches across all widget instances. */
   private static fileCache = new Map<string, Promise<string | undefined>>();
 
+  /** Lazy module loaders keyed by tag name — set by registerLazy(). */
+  private static lazyLoaders = new Map<string, () => Promise<unknown>>();
+
+  /** Cached module promises for lazy-loaded widgets — avoids re-fetching. */
+  private static lazyModules = new Map<string, Promise<unknown>>();
+
   /** App-level context provider set once during router initialization. */
   private static extendContext: ContextProvider | undefined;
 
@@ -111,6 +117,42 @@ export class ComponentElement<TParams, TData> extends HTMLElementBase {
     customElements.define(tagName, BoundElement);
   }
 
+  /**
+   * Register a widget lazily: define the custom element immediately (so SSR
+   * content via Declarative Shadow DOM is adopted), but defer loading the
+   * module until connectedCallback fires. Once loaded, the real component
+   * replaces the placeholder and hydration proceeds normally.
+   */
+  static registerLazy(
+    name: string,
+    files: WidgetFiles | undefined,
+    loader: () => Promise<unknown>,
+  ): void {
+    const tagName = `widget-${name}`;
+    if (!globalThis.customElements || customElements.get(tagName)) return;
+
+    ComponentElement.lazyLoaders.set(tagName, loader);
+
+    // Placeholder component — replaced by the real one once the module loads.
+    // Cast needed because Component is abstract; the real module replaces this.
+    const placeholder = {
+      name,
+      getData: () => Promise.resolve(null),
+      renderHTML: () => '',
+      renderMarkdown: () => '',
+      renderError: () => '',
+      renderMarkdownError: () => '',
+    } as unknown as Component<unknown, unknown>;
+
+    const BoundElement = class extends ComponentElement<unknown, unknown> {
+      constructor() {
+        super(placeholder, files);
+      }
+    };
+
+    customElements.define(tagName, BoundElement);
+  }
+
   /**
    * Promise that resolves when component is ready (data loaded and rendered).
    * Used by router to wait for async components.
@@ -124,6 +166,39 @@ export class ComponentElement<TParams, TData> extends HTMLElementBase {
   }
 
   async connectedCallback(): Promise<void> {
+    // Lazy module loading — resolve actual component before proceeding
+    const tagName = this.tagName.toLowerCase();
+    const lazyLoader = ComponentElement.lazyLoaders.get(tagName);
+    if (lazyLoader) {
+      try {
+        let modulePromise = ComponentElement.lazyModules.get(tagName);
+        if (!modulePromise) {
+          modulePromise = lazyLoader();
+          ComponentElement.lazyModules.set(tagName, modulePromise);
+        }
+        const mod = await modulePromise as Record<string, unknown>;
+        for (const exp of Object.values(mod)) {
+          if (exp && typeof exp === 'object' && 'getData' in exp) {
+            const WidgetClass = exp.constructor as new () => Component<TParams, TData>;
+            this.component = new WidgetClass();
+            break;
+          }
+          if (typeof exp === 'function' && (exp as { prototype?: { getData?: unknown } }).prototype?.getData) {
+            this.component = new (exp as new () => Component<TParams, TData>)();
+            break;
+          }
+        }
+      } catch {
+        // Module failed to load (e.g. raw .ts served without transpilation).
+        // SSR content is already visible — skip hydration gracefully.
+        if (this.hasAttribute(SSR_ATTR)) {
+          this.removeAttribute(SSR_ATTR);
+          this.signalReady();
+          return;
+        }
+      }
+    }
+
     this.component.element = this;
     this.style.contentVisibility = 'auto';
     this.abortController = new AbortController();

package/src/element/markdown.element.ts

@@ -30,6 +30,11 @@ export class MarkdownElement extends HTMLElementBase {
     MarkdownElement.rendererInitPromise = renderer.init ? renderer.init() : null;
   }
 
+  /** Get the current renderer (if set). Used by bootEmrouteApp to pass through to createEmrouteServer. */
+  static getConfiguredRenderer(): MarkdownRenderer | null {
+    return MarkdownElement.renderer;
+  }
+
   /**
    * Get the current renderer, waiting for init if needed.
    */

package/src/renderer/spa/mod.ts

@@ -12,7 +12,7 @@ import { MarkdownElement } from '../../element/markdown.element.ts';
 import { ComponentElement } from '../../element/component.element.ts';
 import { WidgetRegistry } from '../../widget/widget.registry.ts';
 
-export { createEmrouteApp, EmrouteApp, type EmrouteAppOptions } from './thin-client.ts';
+export { bootEmrouteApp, createEmrouteApp, EmrouteApp, type BootOptions, type EmrouteAppOptions } from './thin-client.ts';
 export { ComponentElement, MarkdownElement, RouterSlot, WidgetRegistry };
 export type { SpaMode, WidgetsManifest } from '../../type/widget.type.ts';
 

package/src/renderer/spa/thin-client.ts

@@ -9,9 +9,17 @@
  */
 
 import type { EmrouteServer } from '../../../server/server-api.type.ts';
+import { createEmrouteServer } from '../../../server/emroute.server.ts';
+import { FetchRuntime } from '../../../runtime/fetch.runtime.ts';
+import { ROUTES_MANIFEST_PATH, WIDGETS_MANIFEST_PATH } from '../../../runtime/abstract.runtime.ts';
+import type { RouteNode } from '../../type/route-tree.type.ts';
 import type { NavigateOptions } from '../../type/route.type.ts';
+import type { WidgetManifestEntry } from '../../type/widget.type.ts';
 import { assertSafeRedirect, type BasePath, DEFAULT_BASE_PATH } from '../../route/route.core.ts';
 import { escapeHtml } from '../../util/html.util.ts';
+import { ComponentElement } from '../../element/component.element.ts';
+import { MarkdownElement } from '../../element/markdown.element.ts';
+import { WidgetRegistry } from '../../widget/widget.registry.ts';
 
 /** Options for `createEmrouteApp`. */
 export interface EmrouteAppOptions {
@@ -163,3 +171,92 @@ export async function createEmrouteApp(
   g.__emroute_app = app;
   return app;
 }
+
+// ── Boot ──────────────────────────────────────────────────────────────
+
+/** Options for `bootEmrouteApp`. */
+export interface BootOptions extends EmrouteAppOptions {
+  /** Override the server origin (defaults to `location.origin`). */
+  origin?: string;
+}
+
+/**
+ * Boot the browser app from runtime manifests.
+ *
+ * Fetches route tree and widget manifest as JSON, creates lazy module
+ * loaders via FetchRuntime, registers widgets for deferred hydration,
+ * and wires the Navigation API.
+ *
+ * Consumer `main.ts` calls this after setting up MarkdownElement renderer,
+ * custom elements, etc.
+ */
+export async function bootEmrouteApp(options?: BootOptions): Promise<EmrouteApp> {
+  const origin = options?.origin ?? location.origin;
+  const runtime = new FetchRuntime(origin);
+
+  // Fetch route tree
+  const routesResponse = await runtime.handle(ROUTES_MANIFEST_PATH);
+  if (!routesResponse.ok) {
+    throw new Error(`[emroute] Failed to fetch ${ROUTES_MANIFEST_PATH}: ${routesResponse.status}`);
+  }
+  const routeTree: RouteNode = await routesResponse.json();
+
+  // Fetch widget manifest (optional — app may have no widgets)
+  const widgetsResponse = await runtime.handle(WIDGETS_MANIFEST_PATH);
+  const widgetEntries: WidgetManifestEntry[] = widgetsResponse.ok
+    ? await widgetsResponse.json()
+    : [];
+
+  // Build lazy module loaders for all route + widget modules
+  const moduleLoaders = buildLazyLoaders(routeTree, widgetEntries, runtime);
+
+  // Register widgets eagerly (tag defined immediately, module loads on connectedCallback)
+  const widgets = new WidgetRegistry();
+  for (const entry of widgetEntries) {
+    ComponentElement.registerLazy(entry.name, entry.files, moduleLoaders[entry.modulePath]);
+  }
+
+  // Create the server (reuses the same createEmrouteServer as SSR)
+  const server = await createEmrouteServer({
+    routeTree,
+    widgets,
+    moduleLoaders,
+    markdownRenderer: MarkdownElement.getConfiguredRenderer() ?? undefined,
+  }, runtime);
+
+  return createEmrouteApp(server, options);
+}
+
+/**
+ * Walk the route tree and widget entries to build a map of
+ * `path → () => runtime.loadModule(path)` lazy loaders.
+ */
+function buildLazyLoaders(
+  tree: RouteNode,
+  widgetEntries: WidgetManifestEntry[],
+  runtime: FetchRuntime,
+): Record<string, () => Promise<unknown>> {
+  const paths = new Set<string>();
+
+  function walk(node: RouteNode): void {
+    const modulePath = node.files?.ts ?? node.files?.js;
+    if (modulePath) paths.add(modulePath);
+    if (node.redirect) paths.add(node.redirect);
+    if (node.errorBoundary) paths.add(node.errorBoundary);
+    if (node.children) {
+      for (const child of Object.values(node.children)) walk(child);
+    }
+    if (node.dynamic) walk(node.dynamic.child);
+    if (node.wildcard) walk(node.wildcard.child);
+  }
+
+  walk(tree);
+  for (const entry of widgetEntries) paths.add(entry.modulePath);
+
+  const loaders: Record<string, () => Promise<unknown>> = {};
+  for (const path of paths) {
+    const absolute = path.startsWith('/') ? path : '/' + path;
+    loaders[path] = () => runtime.loadModule(absolute);
+  }
+  return loaders;
+}