@emkodev/emroute 1.7.2 → 1.8.0-beta.1

package/runtime/universal/fs/universal-fs.runtime.ts

@@ -1,4 +1,4 @@
-import { readFile, writeFile, stat, readdir, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, stat, readdir, mkdir, unlink } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import {
   CONTENT_TYPES,
@@ -8,6 +8,7 @@ import {
   Runtime,
   type RuntimeConfig,
   WIDGETS_MANIFEST_PATH,
+  ELEMENTS_MANIFEST_PATH,
 } from '../../abstract.runtime.ts';
 
 /**
@@ -37,6 +38,8 @@ export class UniversalFsRuntime extends Runtime {
     switch (method) {
       case 'PUT':
         return this.write(path, body);
+      case 'DELETE':
+        return this.delete(path);
       default:
         return this.read(path);
     }
@@ -107,6 +110,7 @@ export class UniversalFsRuntime extends Runtime {
         const pathname = path.slice(this.root.length);
         if (pathname === ROUTES_MANIFEST_PATH) return this.resolveRoutesManifest();
         if (pathname === WIDGETS_MANIFEST_PATH) return this.resolveWidgetsManifest();
+        if (pathname === ELEMENTS_MANIFEST_PATH) return this.resolveElementsManifest();
         return new Response('Not Found', { status: 404 });
       }
       return new Response(`Internal Error: ${error}`, { status: 500 });
@@ -136,6 +140,18 @@ export class UniversalFsRuntime extends Runtime {
     }
   }
 
+  private async delete(path: string): Promise<Response> {
+    try {
+      await unlink(path);
+      return new Response(null, { status: 204 });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return new Response('Not Found', { status: 404 });
+      }
+      return new Response(`Delete failed: ${error}`, { status: 500 });
+    }
+  }
+
   override loadModule(path: string): Promise<unknown> {
     return import(this.root + path);
   }

package/server/build.util.ts

@@ -1,9 +1,9 @@
 /**
  * Build Utilities
  *
- * Standalone client bundling — extracted from Runtime so that build is a
+ * Standalone client build step — extracted from Runtime so that build is a
  * separate concern from storage. Call `buildClientBundles()` before
- * `createEmrouteServer()` to produce emroute.js + app.js.
+ * `Emroute.create()` to produce emroute.js + app.js.
  *
  * Route tree and widget manifest are fetched as JSON at boot time by
  * `bootEmrouteApp()` — no longer compiled into app.js.
@@ -20,12 +20,15 @@ import type { Runtime } from '../runtime/abstract.runtime.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';
+  ELEMENTS_MANIFEST_PATH,
+} from '../core/runtime/abstract.runtime.ts';
+import type { RouteNode } from '../core/type/route-tree.type.ts';
+import type { WidgetManifestEntry } from '../core/type/widget.type.ts';
+import type { ElementManifestEntry } from '../core/type/element.type.ts';
 import { generateMainTs } from './codegen.util.ts';
-import type { SpaMode } from '../src/type/widget.type.ts';
+import type { SpaMode } from '../core/type/widget.type.ts';
 
+/** Package specifiers that map to emroute.js via import map. */
 export const EMROUTE_EXTERNALS = [
   '@emkodev/emroute/spa',
   '@emkodev/emroute/overlay',
@@ -34,15 +37,12 @@ export const EMROUTE_EXTERNALS = [
   '@emkodev/emroute/runtime/fetch',
 ] as const;
 
-/** esbuild namespace for virtual `emroute:routes` / `emroute:widgets` modules. */
-export const EMROUTE_VIRTUAL_NS = 'emroute';
-
 export interface BuildOptions {
   /** Runtime instance to read manifests and source files from. */
   runtime: Runtime;
-  /** Filesystem root for esbuild resolution (e.g. process.cwd() or the app directory). */
+  /** Filesystem root for resolving the pre-built emroute.js bundle. */
   root: string;
-  /** SPA mode — skips bundling when 'none'. */
+  /** SPA mode — skips build when 'none'. */
   spa: SpaMode;
   /** Consumer's SPA entry point (e.g. '/main.ts'). When absent, auto-generates one. */
   entryPoint?: string;
@@ -53,13 +53,13 @@ export interface BuildOptions {
 const DEFAULT_BUNDLE_PATHS = { emroute: '/emroute.js', app: '/app.js' };
 
 /**
- * Build client bundles and write them into the runtime.
+ * Build client assets 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 (esbuild only touches consumer code)
+ * - emroute.js — pre-built from dist/ (copied into runtime)
+ * - app.js — consumer entry point (transpiled from .ts, no bundler)
  * - index.html — shell with import map + script tags (if not already present)
  */
 export async function buildClientBundles(options: BuildOptions): Promise<void> {
@@ -71,17 +71,14 @@ export async function buildClientBundles(options: BuildOptions): Promise<void> {
   // 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 — consumer's main.ts bundled with esbuild.
-  // Try filesystem first (where node_modules lives), then runtime, then generate.
+  // App entry point — transpile consumer's main.ts (or generate a default one).
+  // Imports resolve via the import map in index.html — no bundler needed.
   const ep = entryPoint ?? '/main.ts';
   let source: string | undefined;
   try {
@@ -92,19 +89,8 @@ export async function buildClientBundles(options: BuildOptions): Promise<void> {
   }
   source ??= generateMainTs(spa, '@emkodev/emroute');
 
-  const result = await esbuild.build({
-    bundle: true,
-    write: false,
-    format: 'esm' as const,
-    platform: 'browser' as const,
-    stdin: { contents: source, loader: 'ts', resolveDir: root },
-    outfile: paths.app,
-    external: [...EMROUTE_EXTERNALS],
-  });
-
-  for (const file of result.outputFiles) {
-    await runtime.command(paths.app, { body: file.contents as unknown as BodyInit });
-  }
+  const appJs = await runtime.transpile(source);
+  await runtime.command(paths.app, { body: appJs });
 
   // Copy main.css from disk into runtime if it exists (and runtime doesn't have it)
   if ((await runtime.query('/main.css')).status === 404) {
@@ -116,8 +102,6 @@ export async function buildClientBundles(options: BuildOptions): Promise<void> {
 
   // Write shell (index.html) if not already present
   await writeShell(runtime, paths);
-
-  await esbuild.stop();
 }
 
 /**
@@ -146,10 +130,23 @@ async function writeShell(
 ): Promise<void> {
   if ((await runtime.query('/index.html')).status !== 404) return;
 
+  // Base emroute imports
   const imports: Record<string, string> = {};
   for (const pkg of EMROUTE_EXTERNALS) {
     imports[pkg] = paths.emroute;
   }
+
+  // Merge user-provided importmap.json (user entries win on conflict)
+  const mapResponse = await runtime.query('/importmap.json');
+  if (mapResponse.status !== 404) {
+    const userMap = await mapResponse.json() as { imports?: Record<string, string> };
+    if (userMap.imports) {
+      for (const [key, value] of Object.entries(userMap.imports)) {
+        imports[key] = value;
+      }
+    }
+  }
+
   const importMap = JSON.stringify({ imports }, null, 2);
 
   const html = `<!DOCTYPE html>
@@ -251,11 +248,10 @@ async function mergeModules(runtime: Runtime): Promise<void> {
   // 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,
-      };
+      const companions: { html?: string; md?: string; css?: string } = {};
+      if (node.files.html) companions.html = node.files.html;
+      if (node.files.md) companions.md = node.files.md;
+      if (node.files.css) companions.css = node.files.css;
       node.files.js = await transpileAndMerge(runtime, node.files.ts, companions);
       delete node.files.ts;
       delete node.files.html;
@@ -290,6 +286,19 @@ async function mergeModules(runtime: Runtime): Promise<void> {
     }
   }
 
+  // Read element manifest
+  const elementsResponse = await runtime.query(ELEMENTS_MANIFEST_PATH);
+  const elementEntries: ElementManifestEntry[] = elementsResponse.status !== 404
+    ? await elementsResponse.json()
+    : [];
+
+  // Merge element modules
+  for (const entry of elementEntries) {
+    if (entry.modulePath.endsWith('.ts')) {
+      entry.modulePath = await transpileAndMerge(runtime, entry.modulePath);
+    }
+  }
+
   // Write updated manifests back
   await runtime.command(ROUTES_MANIFEST_PATH, {
     body: JSON.stringify(routeTree),
@@ -297,12 +306,9 @@ async function mergeModules(runtime: Runtime): Promise<void> {
   await runtime.command(WIDGETS_MANIFEST_PATH, {
     body: JSON.stringify(widgetEntries),
   });
-}
-
-// ── esbuild loader ────────────────────────────────────────────────────
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function loadEsbuild(): Promise<any> {
-  const consumerRequire = createRequire(process.cwd() + '/');
-  return consumerRequire('esbuild');
+  if (elementEntries.length > 0) {
+    await runtime.command(ELEMENTS_MANIFEST_PATH, {
+      body: JSON.stringify(elementEntries),
+    });
+  }
 }

package/server/codegen.util.ts

@@ -6,7 +6,7 @@
  * fetching manifests, creating the runtime, and wiring navigation.
  */
 
-import type { SpaMode } from '../src/type/widget.type.ts';
+import type { SpaMode } from '../core/type/widget.type.ts';
 
 /**
  * Generate a minimal main.ts entry point.

package/server/emroute.server.ts

@@ -1,420 +1,20 @@
 /**
- * Emroute Server
- *
- * Runtime-agnostic server that handles SSR rendering, manifest resolution,
- * static file serving, and route matching. Works with any Runtime implementation.
- *
- * Usage (standalone):
- * ```ts
- * import { createEmrouteServer } from '@emkodev/emroute/server';
- * import { BunFsRuntime } from '@emkodev/emroute/runtime/bun/fs';
- *
- * const runtime = new BunFsRuntime('.', { routesDir: '/routes' });
- * const emroute = await createEmrouteServer({ spa: 'root' }, runtime);
- *
- * Bun.serve({ fetch: (req) => emroute.handleRequest(req) ?? new Response('Not Found', { status: 404 }) });
- * ```
- *
- * Usage (composable):
- * ```ts
- * const emroute = await createEmrouteServer(config, runtime);
- *
- * Bun.serve({ async fetch(req) {
- *   if (isApiRoute(req)) return handleApi(req);
- *   const response = await emroute.handleRequest(req);
- *   if (response) return response;
- *   return new Response('Not Found', { status: 404 });
- * }});
- * ```
+ * Emroute — re-exports from core/server.
  */
+export { Emroute } from '../core/server/emroute.server.ts';
 
-import { DEFAULT_BASE_PATH } from '../src/route/route.core.ts';
-import { RouteTrie } from '../src/route/route.trie.ts';
-import { SsrHtmlRouter } from '../src/renderer/ssr/html.renderer.ts';
-import { SsrMdRouter } from '../src/renderer/ssr/md.renderer.ts';
-import type { RouteNode } from '../src/type/route-tree.type.ts';
-import type { WidgetManifestEntry } from '../src/type/widget.type.ts';
-import { WidgetRegistry } from '../src/widget/widget.registry.ts';
-import type { WidgetComponent } from '../src/component/widget.component.ts';
-import { escapeHtml } from '../src/util/html.util.ts';
-import { rewriteMdLinks } from '../src/util/md.util.ts';
-import {
-  ROUTES_MANIFEST_PATH,
-  Runtime,
-  WIDGETS_MANIFEST_PATH,
-} from '../runtime/abstract.runtime.ts';
-import type { EmrouteServer, EmrouteServerConfig } from './server-api.type.ts';
+// ── Deprecated aliases ───────────────────────────────────────────────
 
-// ── Module loaders ─────────────────────────────────────────────────────
+import { Emroute as _Emroute } from '../core/server/emroute.server.ts';
+import type { Runtime } from '../core/runtime/abstract.runtime.ts';
 
-/**
- * Collect all .ts module paths from a RouteNode tree and create loaders.
- * Uses `runtime.loadModule()` — each runtime decides how to load modules
- * (filesystem import, SQLite transpile + blob URL, etc.).
- */
-function createModuleLoaders(
-  tree: RouteNode,
-  runtime: Runtime,
-): 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);
-
-  const loaders: Record<string, () => Promise<unknown>> = {};
-  for (const path of paths) {
-    loaders[path] = () => runtime.loadModule(path);
-  }
-  return loaders;
-}
-
-// ── Widget helpers ─────────────────────────────────────────────────────
-
-/** Find a WidgetComponent export from a module. */
-function extractWidgetExport(
-  mod: Record<string, unknown>,
-): WidgetComponent | null {
-  for (const value of Object.values(mod)) {
-    if (!value) continue;
-    if (typeof value === 'object' && 'getData' in value) {
-      return value as WidgetComponent;
-    }
-    if (typeof value === 'function' && value.prototype?.getData) {
-      return new (value as new () => WidgetComponent)();
-    }
-  }
-  return null;
-}
-
-/** Import widget modules for SSR via runtime.loadModule(). */
-async function importWidgets(
-  entries: WidgetManifestEntry[],
-  runtime: Runtime,
-  manual?: WidgetRegistry,
-): Promise<{
-  registry: WidgetRegistry;
-  widgetFiles: Record<string, { html?: string; md?: string; css?: string }>;
-}> {
-  const registry = new WidgetRegistry();
-  const widgetFiles: Record<string, { html?: string; md?: string; css?: string }> = {};
-
-  for (const entry of entries) {
-    try {
-      const runtimePath = entry.modulePath.startsWith('/')
-        ? entry.modulePath
-        : `/${entry.modulePath}`;
-
-      const mod = await runtime.loadModule(runtimePath) as Record<string, unknown>;
-      const instance = extractWidgetExport(mod);
-      if (!instance) continue;
-      registry.add(instance);
-
-      // Prefer inlined __files from merged module over manifest paths
-      const inlined = mod.__files;
-      if (inlined && typeof inlined === 'object') {
-        widgetFiles[entry.name] = inlined as { html?: string; md?: string; css?: string };
-      } else if (entry.files) {
-        widgetFiles[entry.name] = entry.files;
-      }
-    } catch (e) {
-      console.error(`[emroute] Failed to load widget ${entry.modulePath}:`, e);
-      if (entry.files) widgetFiles[entry.name] = entry.files;
-    }
-  }
-
-  if (manual) {
-    for (const widget of manual) {
-      registry.add(widget);
-    }
-  }
-
-  return { registry, widgetFiles };
-}
-
-// ── HTML shell ─────────────────────────────────────────────────────────
-
-/** Build a default HTML shell. */
-function buildHtmlShell(title: string, htmlBase: string): string {
-  const baseTag = htmlBase ? `\n  <base href="${escapeHtml(htmlBase)}/">` : '';
-  return `<!DOCTYPE html>
-<html>
-<head>${baseTag}
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>${escapeHtml(title)}</title>
-  <style>@view-transition { navigation: auto; } router-slot { display: contents; }</style>
-</head>
-<body>
-  <router-slot></router-slot>
-</body>
-</html>`;
-}
-
-/** Inject SSR-rendered content into an HTML shell. */
-function injectSsrContent(
-  html: string,
-  content: string,
-  title: string | undefined,
-  ssrRoute?: string,
-): string {
-  const slotPattern = /<router-slot\b[^>]*>.*?<\/router-slot>/s;
-  if (!slotPattern.test(html)) return html;
-
-  const ssrAttr = ssrRoute ? ` data-ssr-route="${ssrRoute}"` : '';
-  html = html.replace(slotPattern, `<router-slot${ssrAttr}>${content}</router-slot>`);
-
-  if (title) {
-    html = html.replace(/<title>[^<]*<\/title>/, `<title>${escapeHtml(title)}</title>`);
-  }
-
-  return html;
-}
-
-/** Read the HTML shell from runtime, with fallback to a default shell. */
-async function resolveShell(
-  runtime: Runtime,
-  title: string,
-  htmlBase: string,
-): Promise<string> {
-  const response = await runtime.query('/index.html');
-  if (response.status !== 404) return await response.text();
-  return buildHtmlShell(title, htmlBase);
-}
-
-// ── More path helpers ─────────────────────────────────────────────────
+/** @deprecated Use `Emroute` class directly. */
+export type EmrouteServer = _Emroute;
 
-// ── createEmrouteServer ────────────────────────────────────────────────
-
-/**
- * Create an emroute server.
- *
- * All paths are Runtime-relative (starting with `/`). Runtime root = appRoot.
- */
-export async function createEmrouteServer(
-  config: EmrouteServerConfig,
+/** @deprecated Use `Emroute.create(config, runtime)`. */
+export function createEmrouteServer(
+  config: Parameters<typeof _Emroute.create>[0],
   runtime: Runtime,
-): Promise<EmrouteServer> {
-  const {
-    spa = 'root',
-  } = config;
-
-  const { html: htmlBase, md: mdBase, app: appBase } = config.basePath ?? DEFAULT_BASE_PATH;
-
-  // ── Route tree (read from runtime) ──────────────────────────────────
-
-  let routeTree: RouteNode;
-
-  if (config.routeTree) {
-    routeTree = config.routeTree;
-  } else {
-    const manifestResponse = await runtime.query(ROUTES_MANIFEST_PATH);
-    if (manifestResponse.status === 404) {
-      throw new Error(
-        `[emroute] ${ROUTES_MANIFEST_PATH} not found in runtime. ` +
-          'Provide routeTree in config or ensure the runtime produces it.',
-      );
-    }
-    routeTree = await manifestResponse.json();
-  }
-
-  const moduleLoaders = config.moduleLoaders ?? createModuleLoaders(routeTree, runtime);
-  const resolver = new RouteTrie(routeTree);
-
-  // ── Widgets (read from runtime) ────────────────────────────────────
-
-  let widgets: WidgetRegistry | undefined = config.widgets;
-  let widgetFiles: Record<string, { html?: string; md?: string; css?: string }> = {};
-  let discoveredWidgetEntries: WidgetManifestEntry[] = [];
-
-  const widgetsResponse = await runtime.query(WIDGETS_MANIFEST_PATH);
-  if (widgetsResponse.status !== 404) {
-    discoveredWidgetEntries = await widgetsResponse.json();
-    if (config.widgets) {
-      // Widgets pre-provided (e.g. browser bundle) — just collect file paths
-      widgets = config.widgets;
-      for (const entry of discoveredWidgetEntries) {
-        if (entry.files) widgetFiles[entry.name] = entry.files;
-      }
-    } else {
-      const imported = await importWidgets(discoveredWidgetEntries, runtime);
-      widgets = imported.registry;
-      widgetFiles = imported.widgetFiles;
-    }
-  }
-
-  // ── SSR routers ──────────────────────────────────────────────────────
-
-  let ssrHtmlRouter: SsrHtmlRouter | null = null;
-  let ssrMdRouter: SsrMdRouter | null = null;
-
-  function buildSsrRouters(): void {
-    if (spa === 'only') {
-      ssrHtmlRouter = null;
-      ssrMdRouter = null;
-      return;
-    }
-
-    ssrHtmlRouter = new SsrHtmlRouter(resolver, {
-      fileReader: (path) => runtime.query(path, { as: 'text' }),
-      moduleLoaders,
-      markdownRenderer: config.markdownRenderer,
-      extendContext: config.extendContext,
-      widgets,
-      widgetFiles,
-    });
-
-    ssrMdRouter = new SsrMdRouter(resolver, {
-      fileReader: (path) => runtime.query(path, { as: 'text' }),
-      moduleLoaders,
-      extendContext: config.extendContext,
-      widgets,
-      widgetFiles,
-    });
-  }
-
-  buildSsrRouters();
-
-  // ── HTML shell ───────────────────────────────────────────────────────
-
-  const title = config.title ?? 'emroute';
-  let shell = await resolveShell(runtime, title, htmlBase);
-
-  // Auto-discover main.css and inject <link> into <head>
-  if ((await runtime.query('/main.css')).status !== 404) {
-    shell = shell.replace('</head>', '  <link rel="stylesheet" href="/main.css">\n</head>');
-  }
-
-  // ── handleRequest ────────────────────────────────────────────────────
-
-  async function handleRequest(req: Request): Promise<Response | null> {
-    const url = new URL(req.url);
-    const pathname = url.pathname;
-
-    const mdPrefix = mdBase + '/';
-    const htmlPrefix = htmlBase + '/';
-    const appPrefix = appBase + '/';
-
-    // SSR Markdown: /md/*
-    if (
-      ssrMdRouter &&
-      (pathname.startsWith(mdPrefix) || pathname === mdBase)
-    ) {
-      // Normalize trailing slash: /md/about/ → 301 /md/about
-      const routePath = pathname === mdBase ? '/' : pathname.slice(mdBase.length);
-      if (routePath.length > 1 && routePath.endsWith('/')) {
-        const canonical = mdBase + routePath.slice(0, -1) + (url.search || '');
-        return Response.redirect(new URL(canonical, url.origin), 301);
-      }
-      try {
-        const routeUrl = new URL(routePath + url.search, url.origin);
-        const { content, status, redirect } = await ssrMdRouter.render(routeUrl, req.signal);
-        if (redirect) {
-          const target = redirect.startsWith('/') ? mdBase + redirect : redirect;
-          return Response.redirect(new URL(target, url.origin), status);
-        }
-        return new Response(rewriteMdLinks(content, mdBase, [mdBase, htmlBase]), {
-          status,
-          headers: { 'Content-Type': 'text/markdown; charset=utf-8; variant=CommonMark' },
-        });
-      } catch (e) {
-        console.error(`[emroute] Error rendering ${pathname}:`, e);
-        return new Response('Internal Server Error', { status: 500 });
-      }
-    }
-
-    // SSR HTML: /html/*
-    if (
-      ssrHtmlRouter &&
-      (pathname.startsWith(htmlPrefix) || pathname === htmlBase)
-    ) {
-      // Normalize trailing slash: /html/about/ → 301 /html/about
-      const routePath = pathname === htmlBase ? '/' : pathname.slice(htmlBase.length);
-      if (routePath.length > 1 && routePath.endsWith('/')) {
-        const canonical = htmlBase + routePath.slice(0, -1) + (url.search || '');
-        return Response.redirect(new URL(canonical, url.origin), 301);
-      }
-      try {
-        const routeUrl = new URL(routePath + url.search, url.origin);
-        const result = await ssrHtmlRouter.render(routeUrl, req.signal);
-        if (result.redirect) {
-          const target = result.redirect.startsWith('/') ? htmlBase + result.redirect : result.redirect;
-          return Response.redirect(new URL(target, url.origin), result.status);
-        }
-        const ssrTitle = result.title ?? title;
-        const html = injectSsrContent(shell, result.content, ssrTitle, pathname);
-        return new Response(html, {
-          status: result.status,
-          headers: { 'Content-Type': 'text/html; charset=utf-8' },
-        });
-      } catch (e) {
-        console.error(`[emroute] Error rendering ${pathname}:`, e);
-        return new Response('Internal Server Error', { status: 500 });
-      }
-    }
-
-    // /app/* — serve shell (browser JS takes over via createEmrouteApp)
-    if (pathname.startsWith(appPrefix) || pathname === appBase) {
-      return new Response(shell, {
-        status: 200,
-        headers: { 'Content-Type': 'text/html; charset=utf-8' },
-      });
-    }
-
-    // /html/* or /md/* that wasn't handled by SSR (e.g. 'only' mode) — serve shell
-    if (
-      pathname.startsWith(htmlPrefix) || pathname === htmlBase ||
-      pathname.startsWith(mdPrefix) || pathname === mdBase
-    ) {
-      return new Response(shell, {
-        status: 200,
-        headers: { 'Content-Type': 'text/html; charset=utf-8' },
-      });
-    }
-
-    // Static files — only try runtime for paths with a file extension
-    const lastSegment = pathname.split('/').pop() ?? '';
-    if (lastSegment.includes('.')) {
-      const fileResponse = await runtime.handle(pathname);
-      if (fileResponse.status === 200) return fileResponse;
-      return null;
-    }
-
-    // Bare paths — redirect to /app/* in root/only modes, /html/* otherwise.
-    const base = (spa === 'root' || spa === 'only') ? appBase : htmlBase;
-    const bare = pathname === '/' ? '' : pathname.slice(1).replace(/\/$/, '');
-    return Response.redirect(new URL(`${base}/${bare}`, url.origin), 302);
-  }
-
-  // ── Return ───────────────────────────────────────────────────────────
-
-  return {
-    handleRequest,
-    get htmlRouter() {
-      return ssrHtmlRouter;
-    },
-    get mdRouter() {
-      return ssrMdRouter;
-    },
-    get routeTree() {
-      return routeTree;
-    },
-    get widgetEntries() {
-      return discoveredWidgetEntries;
-    },
-    get shell() {
-      return shell;
-    },
-  };
+): Promise<_Emroute> {
+  return _Emroute.create(config, runtime);
 }