@emkodev/emroute 1.0.3 → 1.6.0

package/runtime/bun/fs/bun-fs.runtime.ts

@@ -0,0 +1,245 @@
+import { stat, readdir, mkdir } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import {
+  CONTENT_TYPES,
+  DEFAULT_ROUTES_DIR,
+  DEFAULT_WIDGETS_DIR,
+  EMROUTE_EXTERNALS,
+  type FetchParams,
+  type FetchReturn,
+  ROUTES_MANIFEST_PATH,
+  Runtime,
+  type RuntimeConfig,
+  WIDGETS_MANIFEST_PATH,
+} from '../../abstract.runtime.ts';
+import { createManifestPlugin } from '../../../server/esbuild-manifest.plugin.ts';
+import { createRuntimeLoaderPlugin } from '../esbuild-runtime-loader.plugin.ts';
+import { generateMainTs } from '../../../server/codegen.util.ts';
+
+export class BunFsRuntime extends Runtime {
+  private readonly root: string;
+
+  constructor(root: string, config: RuntimeConfig = {}) {
+    if (config.entryPoint && !config.bundlePaths) {
+      config.bundlePaths = { emroute: '/emroute.js', app: '/app.js' };
+    }
+    super(config);
+    const abs = resolve(root);
+    this.root = abs.endsWith('/') ? abs.slice(0, -1) : abs;
+  }
+
+  handle(
+    resource: FetchParams[0],
+    init?: FetchParams[1],
+  ): FetchReturn {
+    const [pathname, method, body] = this.parse(resource, init);
+    const path = `${this.root}${pathname}`;
+
+    switch (method) {
+      case 'PUT':
+        return this.write(path, body);
+      default:
+        return this.read(path);
+    }
+  }
+
+  query(
+    resource: FetchParams[0],
+    options: FetchParams[1] & { as: 'text' },
+  ): Promise<string>;
+  query(
+    resource: FetchParams[0],
+    options?: FetchParams[1],
+  ): FetchReturn;
+  query(
+    resource: FetchParams[0],
+    options?: FetchParams[1] & { as?: 'text' },
+  ): Promise<Response | string> {
+    if (options?.as === 'text') {
+      const pathname = this.parsePath(resource);
+      return Bun.file(`${this.root}${pathname}`).text();
+    }
+    return this.handle(resource, options);
+  }
+
+  private parsePath(resource: FetchParams[0]): string {
+    if (typeof resource === 'string') return decodeURIComponent(resource);
+    if (resource instanceof URL) return decodeURIComponent(resource.pathname);
+    return decodeURIComponent(new URL(resource.url).pathname);
+  }
+
+  private parse(
+    resource: FetchParams[0],
+    init?: RequestInit,
+  ): [string, string, BodyInit | null] {
+    const pathname = this.parsePath(resource);
+    if (typeof resource === 'string' || resource instanceof URL) {
+      return [pathname, init?.method ?? 'GET', init?.body ?? null];
+    }
+    return [
+      pathname,
+      init?.method ?? resource.method,
+      init?.body ?? resource.body,
+    ];
+  }
+
+  private async read(path: string): Promise<Response> {
+    try {
+      const info = await stat(path);
+
+      if (info.isDirectory()) {
+        return this.list(path);
+      }
+
+      const content = new Uint8Array(await Bun.file(path).arrayBuffer());
+      const ext = path.slice(path.lastIndexOf('.')).toLowerCase();
+      const headers: HeadersInit = {
+        'Content-Type': CONTENT_TYPES.get(ext) ?? 'application/octet-stream',
+        'Content-Length': content.byteLength.toString(),
+      };
+
+      if (info.mtime) {
+        headers['Last-Modified'] = info.mtime.toUTCString();
+      }
+
+      return new Response(content, { status: 200, headers });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        const pathname = path.slice(this.root.length);
+        if (pathname === ROUTES_MANIFEST_PATH) return this.resolveRoutesManifest();
+        if (pathname === WIDGETS_MANIFEST_PATH) return this.resolveWidgetsManifest();
+        return new Response('Not Found', { status: 404 });
+      }
+      return new Response(`Internal Error: ${error}`, { status: 500 });
+    }
+  }
+
+  private async list(path: string): Promise<Response> {
+    const entries: string[] = [];
+    const dirents = await readdir(path, { withFileTypes: true });
+    for (const entry of dirents) {
+      entries.push(entry.name + (entry.isDirectory() ? '/' : ''));
+    }
+    return Response.json(entries);
+  }
+
+  private async write(path: string, body: BodyInit | null): Promise<Response> {
+    try {
+      const content = body
+        ? new Uint8Array(await new Response(body).arrayBuffer())
+        : new Uint8Array();
+      const dir = path.slice(0, path.lastIndexOf('/'));
+      if (dir) await mkdir(dir, { recursive: true });
+      await Bun.write(path, content);
+      return new Response(null, { status: 204 });
+    } catch (error) {
+      return new Response(`Write failed: ${error}`, { status: 500 });
+    }
+  }
+
+  override loadModule(path: string): Promise<unknown> {
+    return import(this.root + path);
+  }
+
+  // ── Bundling ─────────────────────────────────────────────────────────
+
+  override async bundle(): Promise<void> {
+    if (this.config.spa === 'none') return;
+    const paths = this.config.bundlePaths;
+    if (!paths) return;
+
+    const esbuild = await BunFsRuntime.esbuild();
+    const builds: Promise<{ outputFiles: { path: string; contents: Uint8Array }[] }>[] = [];
+    const shared = { bundle: true, write: false, format: 'esm' as const, platform: 'browser' as const };
+    const runtimeLoader = createRuntimeLoaderPlugin({ runtime: this, root: this.root });
+
+    // Emroute SPA bundle — resolve from consumer's node_modules (no runtime loader needed)
+    const consumerRequire = createRequire(this.root + '/');
+    const spaEntry = consumerRequire.resolve('@emkodev/emroute/spa');
+    builds.push(esbuild.build({
+      ...shared,
+      entryPoints: [spaEntry],
+      outfile: `${this.root}${paths.emroute}`,
+    }));
+
+    // App bundle — generate main.ts if absent, virtual plugin resolves manifests
+    if (this.config.entryPoint) {
+      if ((await this.query(this.config.entryPoint)).status === 404) {
+        const hasRoutes = (await this.query((this.config.routesDir ?? DEFAULT_ROUTES_DIR) + '/')).status !== 404;
+        const hasWidgets = (await this.query((this.config.widgetsDir ?? DEFAULT_WIDGETS_DIR) + '/')).status !== 404;
+        const code = generateMainTs('root', hasRoutes, hasWidgets, '@emkodev/emroute');
+        await this.command(this.config.entryPoint, { body: code });
+      }
+      const manifestPlugin = createManifestPlugin({
+        runtime: this,
+        basePath: '/html',
+        resolveDir: this.root,
+      });
+      builds.push(esbuild.build({
+        ...shared,
+        entryPoints: [`${this.root}${this.config.entryPoint}`],
+        outfile: `${this.root}${paths.app}`,
+        external: [...EMROUTE_EXTERNALS],
+        plugins: [manifestPlugin, runtimeLoader],
+      }));
+    }
+
+    // Widgets bundle
+    if (paths.widgets) {
+      const widgetsTsPath = paths.widgets.replace('.js', '.ts');
+      if ((await this.query(widgetsTsPath)).status !== 404) {
+        builds.push(esbuild.build({
+          ...shared,
+          entryPoints: [`${this.root}${widgetsTsPath}`],
+          outfile: `${this.root}${paths.widgets}`,
+          external: [...EMROUTE_EXTERNALS],
+          plugins: [runtimeLoader],
+        }));
+      }
+    }
+
+    const results = await Promise.all(builds);
+
+    // Write all output files through the runtime
+    for (const result of results) {
+      for (const file of result.outputFiles) {
+        const runtimePath = file.path.startsWith(this.root)
+          ? file.path.slice(this.root.length)
+          : '/' + file.path;
+        await this.command(runtimePath, { body: file.contents as unknown as BodyInit });
+      }
+    }
+
+    await this.writeShell(paths);
+
+    await esbuild.stop();
+    BunFsRuntime._esbuild = null;
+  }
+
+  // ── Transpile / esbuild ───────────────────────────────────────────────
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private static _esbuild: any = null;
+
+  private static async esbuild() {
+    if (!BunFsRuntime._esbuild) {
+      // Resolve esbuild from the consumer's node_modules, not the package's
+      const consumerRequire = createRequire(process.cwd() + '/');
+      BunFsRuntime._esbuild = consumerRequire('esbuild');
+    }
+    return BunFsRuntime._esbuild;
+  }
+
+  static override transpile(source: string): Promise<string> {
+    const transpiler = new Bun.Transpiler({ loader: 'ts' });
+    return Promise.resolve(transpiler.transformSync(source));
+  }
+
+  static override async stopBundler(): Promise<void> {
+    if (BunFsRuntime._esbuild) {
+      await BunFsRuntime._esbuild.stop();
+      BunFsRuntime._esbuild = null;
+    }
+  }
+}

package/runtime/bun/sqlite/bun-sqlite.runtime.ts

@@ -0,0 +1,279 @@
+import { createRequire } from 'node:module';
+import { Database } from 'bun:sqlite';
+import {
+  CONTENT_TYPES,
+  DEFAULT_ROUTES_DIR,
+  DEFAULT_WIDGETS_DIR,
+  EMROUTE_EXTERNALS,
+  type FetchParams,
+  type FetchReturn,
+  ROUTES_MANIFEST_PATH,
+  Runtime,
+  type RuntimeConfig,
+  WIDGETS_MANIFEST_PATH,
+} from '../../abstract.runtime.ts';
+import { createManifestPlugin } from '../../../server/esbuild-manifest.plugin.ts';
+import { createRuntimeLoaderPlugin } from '../esbuild-runtime-loader.plugin.ts';
+import { generateMainTs } from '../../../server/codegen.util.ts';
+
+export class BunSqliteRuntime extends Runtime {
+  private readonly db: Database;
+  private readonly stmtGet: ReturnType<Database['prepare']>;
+  private readonly stmtSet: ReturnType<Database['prepare']>;
+  private readonly stmtList: ReturnType<Database['prepare']>;
+  private readonly stmtHas: ReturnType<Database['prepare']>;
+
+  constructor(path: string = ':memory:', config: RuntimeConfig = {}) {
+    if (config.entryPoint && !config.bundlePaths) {
+      config.bundlePaths = { emroute: '/emroute.js', app: '/app.js' };
+    }
+    super(config);
+    this.db = new Database(path);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        data BLOB NOT NULL,
+        mtime TEXT NOT NULL
+      )
+    `);
+    this.stmtGet = this.db.prepare('SELECT data, mtime FROM files WHERE path = ?');
+    this.stmtSet = this.db.prepare('INSERT OR REPLACE INTO files (path, data, mtime) VALUES (?, ?, ?)');
+    this.stmtList = this.db.prepare("SELECT DISTINCT path FROM files WHERE path LIKE ? || '%'");
+    this.stmtHas = this.db.prepare("SELECT 1 FROM files WHERE path LIKE ? || '%' LIMIT 1");
+  }
+
+  handle(
+    resource: FetchParams[0],
+    init?: FetchParams[1],
+  ): FetchReturn {
+    const [pathname, method, body] = this.parse(resource, init);
+
+    switch (method) {
+      case 'PUT':
+        return this.write(pathname, body);
+      default:
+        return this.read(pathname);
+    }
+  }
+
+  query(
+    resource: FetchParams[0],
+    options: FetchParams[1] & { as: 'text' },
+  ): Promise<string>;
+  query(
+    resource: FetchParams[0],
+    options?: FetchParams[1],
+  ): FetchReturn;
+  query(
+    resource: FetchParams[0],
+    options?: FetchParams[1] & { as?: 'text' },
+  ): Promise<Response | string> {
+    if (options?.as === 'text') {
+      const pathname = this.parsePath(resource);
+      const row = this.stmtGet.get(pathname) as { data: Uint8Array } | null;
+      if (!row) {
+        return Promise.reject(new Error(`Not found: ${pathname}`));
+      }
+      return Promise.resolve(new TextDecoder().decode(row.data));
+    }
+    return this.handle(resource, options);
+  }
+
+  override async loadModule(path: string): Promise<unknown> {
+    const source = await this.query(path, { as: 'text' });
+    const code = path.endsWith('.ts')
+      ? await BunSqliteRuntime.transpile(source)
+      : source;
+
+    const blob = new Blob([code], { type: 'text/javascript' });
+    const url = URL.createObjectURL(blob);
+    try {
+      return await import(url);
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  // ── Bundling ─────────────────────────────────────────────────────────
+
+  override async bundle(): Promise<void> {
+    if (this.config.spa === 'none') return;
+    const paths = this.config.bundlePaths;
+    if (!paths) return;
+
+    const esbuild = await BunSqliteRuntime.esbuild();
+    const builds: Promise<{ outputFiles: { path: string; contents: Uint8Array }[] }>[] = [];
+    const shared = { bundle: true, write: false, format: 'esm' as const, platform: 'browser' as const };
+    const runtimeLoader = createRuntimeLoaderPlugin({ runtime: this, root: '' });
+
+    // Emroute SPA bundle — resolve from consumer's node_modules (no runtime loader needed)
+    const consumerRequire = createRequire(process.cwd() + '/');
+    const spaEntry = consumerRequire.resolve('@emkodev/emroute/spa');
+    builds.push(esbuild.build({
+      ...shared,
+      entryPoints: [spaEntry],
+      outfile: paths.emroute,
+    }));
+
+    // App bundle — generate main.ts if absent, virtual plugin resolves manifests
+    if (this.config.entryPoint) {
+      if ((await this.query(this.config.entryPoint)).status === 404) {
+        const hasRoutes = (await this.query((this.config.routesDir ?? DEFAULT_ROUTES_DIR) + '/')).status !== 404;
+        const hasWidgets = (await this.query((this.config.widgetsDir ?? DEFAULT_WIDGETS_DIR) + '/')).status !== 404;
+        const code = generateMainTs('root', hasRoutes, hasWidgets, '@emkodev/emroute');
+        await this.command(this.config.entryPoint, { body: code });
+      }
+      const manifestPlugin = createManifestPlugin({
+        runtime: this,
+        basePath: '/html',
+        resolveDir: process.cwd(),
+      });
+      builds.push(esbuild.build({
+        ...shared,
+        entryPoints: [this.config.entryPoint],
+        outfile: paths.app,
+        external: [...EMROUTE_EXTERNALS],
+        plugins: [manifestPlugin, runtimeLoader],
+      }));
+    }
+
+    // Widgets bundle
+    if (paths.widgets) {
+      const widgetsTsPath = paths.widgets.replace('.js', '.ts');
+      if ((await this.query(widgetsTsPath)).status !== 404) {
+        builds.push(esbuild.build({
+          ...shared,
+          entryPoints: [widgetsTsPath],
+          outfile: paths.widgets,
+          external: [...EMROUTE_EXTERNALS],
+          plugins: [runtimeLoader],
+        }));
+      }
+    }
+
+    const results = await Promise.all(builds);
+
+    // Write all output files through the runtime
+    for (const result of results) {
+      for (const file of result.outputFiles) {
+        // outfile paths are relative — ensure leading /
+        const runtimePath = file.path.startsWith('/') ? file.path : '/' + file.path;
+        await this.command(runtimePath, { body: file.contents as unknown as BodyInit });
+      }
+    }
+
+    await this.writeShell(paths);
+
+    await esbuild.stop();
+    BunSqliteRuntime._esbuild = null;
+  }
+
+  // ── Private ─────────────────────────────────────────────────────────
+
+  private async read(path: string): Promise<Response> {
+    if (path.endsWith('/')) {
+      const children = this.listChildren(path);
+      if (children.length === 0) {
+        return new Response('Not Found', { status: 404 });
+      }
+      return Response.json(children);
+    }
+
+    if (!this.stmtGet.get(path) && this.hasChildren(path + '/')) {
+      return Response.json(this.listChildren(path + '/'));
+    }
+
+    const row = this.stmtGet.get(path) as { data: Uint8Array; mtime: string } | null;
+    if (!row) {
+      if (path === ROUTES_MANIFEST_PATH) return this.resolveRoutesManifest();
+      if (path === WIDGETS_MANIFEST_PATH) return this.resolveWidgetsManifest();
+      return new Response('Not Found', { status: 404 });
+    }
+
+    const data = new Uint8Array(row.data);
+    const ext = path.slice(path.lastIndexOf('.')).toLowerCase();
+    const headers: HeadersInit = {
+      'Content-Type': CONTENT_TYPES.get(ext) ?? 'application/octet-stream',
+      'Content-Length': data.byteLength.toString(),
+      'Last-Modified': new Date(row.mtime).toUTCString(),
+    };
+
+    return new Response(data, { status: 200, headers });
+  }
+
+  private async write(path: string, body: BodyInit | null): Promise<Response> {
+    const data = body
+      ? new Uint8Array(await new Response(body).arrayBuffer())
+      : new Uint8Array();
+    this.stmtSet.run(path, data, new Date().toISOString());
+    return new Response(null, { status: 204 });
+  }
+
+  private listChildren(prefix: string): string[] {
+    const rows = this.stmtList.all(prefix) as { path: string }[];
+    const entries = new Set<string>();
+    for (const row of rows) {
+      const rest = row.path.slice(prefix.length);
+      const slashIdx = rest.indexOf('/');
+      if (slashIdx === -1) {
+        entries.add(rest);
+      } else {
+        entries.add(rest.slice(0, slashIdx + 1));
+      }
+    }
+    return [...entries];
+  }
+
+  private hasChildren(prefix: string): boolean {
+    return this.stmtHas.get(prefix) !== null;
+  }
+
+  // ── Transpile / esbuild ───────────────────────────────────────────────
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private static _esbuild: any = null;
+
+  private static async esbuild() {
+    if (!BunSqliteRuntime._esbuild) {
+      BunSqliteRuntime._esbuild = await import('esbuild');
+    }
+    return BunSqliteRuntime._esbuild;
+  }
+
+  static override transpile(source: string): Promise<string> {
+    const transpiler = new Bun.Transpiler({ loader: 'ts' });
+    return Promise.resolve(transpiler.transformSync(source));
+  }
+
+  static override async stopBundler(): Promise<void> {
+    if (BunSqliteRuntime._esbuild) {
+      await BunSqliteRuntime._esbuild.stop();
+      BunSqliteRuntime._esbuild = null;
+    }
+  }
+
+  private parsePath(resource: FetchParams[0]): string {
+    if (typeof resource === 'string') return decodeURIComponent(resource);
+    if (resource instanceof URL) return decodeURIComponent(resource.pathname);
+    return decodeURIComponent(new URL(resource.url).pathname);
+  }
+
+  private parse(
+    resource: FetchParams[0],
+    init?: RequestInit,
+  ): [string, string, BodyInit | null] {
+    const pathname = this.parsePath(resource);
+    if (typeof resource === 'string' || resource instanceof URL) {
+      return [pathname, init?.method ?? 'GET', init?.body ?? null];
+    }
+    return [
+      pathname,
+      init?.method ?? resource.method,
+      init?.body ?? resource.body,
+    ];
+  }
+}

package/runtime/sitemap.generator.ts

@@ -0,0 +1,180 @@
+/**
+ * Sitemap Generator — Opt-in Submodule
+ *
+ * Generates sitemap.xml from a RoutesManifest. Pure function over manifest data,
+ * no filesystem access needed.
+ *
+ * Usage:
+ *   import { generateSitemap } from '@emkodev/emroute/runtime/sitemap';
+ *   const xml = await generateSitemap(manifest, { baseUrl: 'https://example.com' });
+ *
+ * Per sitemaps.org protocol:
+ * - <loc> is required (full absolute URL)
+ * - <lastmod>, <changefreq>, <priority> are optional
+ * - URLs use route patterns as-is (patterns include basePath when present)
+ * - Max 50,000 URLs per sitemap file
+ *
+ * @see https://www.sitemaps.org/protocol.html
+ */
+
+import { escapeHtml } from '../src/util/html.util.ts';
+import type { RoutesManifest } from '../src/type/route.type.ts';
+
+/** Valid changefreq values per sitemaps.org protocol. */
+export type Changefreq =
+  | 'always'
+  | 'hourly'
+  | 'daily'
+  | 'weekly'
+  | 'monthly'
+  | 'yearly'
+  | 'never';
+
+/** Per-route sitemap overrides. */
+export interface SitemapRouteOptions {
+  /** W3C Datetime, e.g. '2025-06-15' or '2025-06-15T10:30:00+00:00' */
+  lastmod?: string;
+  changefreq?: Changefreq;
+  /** 0.0–1.0, default 0.5 per protocol */
+  priority?: number;
+}
+
+/** Options for sitemap generation. */
+export interface SitemapOptions {
+  /** Site origin with protocol, e.g. 'https://example.com'. No trailing slash. */
+  baseUrl: string;
+
+  /** Per-route overrides keyed by route pattern (including basePath if present). */
+  routes?: Record<string, SitemapRouteOptions>;
+
+  /** Defaults applied when a route has no specific override. */
+  defaults?: SitemapRouteOptions;
+
+  /**
+   * Enumerators for dynamic routes. Keyed by route pattern (e.g. '/html/projects/:id').
+   * Each function returns concrete path segments to substitute for the parameter.
+   * Dynamic routes without an enumerator are excluded from the sitemap.
+   */
+  enumerators?: Record<string, () => Promise<string[]>>;
+
+  /**
+   * Base path to prepend to patterns when manifest contains bare patterns.
+   * When the manifest already has prefixed patterns (e.g. from generateManifestCode),
+   * leave this unset.
+   */
+  basePath?: string;
+}
+
+/** A resolved URL entry before XML serialization. */
+interface SitemapEntry {
+  loc: string;
+  lastmod?: string;
+  changefreq?: Changefreq;
+  priority?: number;
+}
+
+const XML_HEADER = '<?xml version="1.0" encoding="UTF-8"?>';
+const URLSET_OPEN = '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
+const URLSET_CLOSE = '</urlset>';
+const MAX_URLS = 50_000;
+
+/** Check if a route pattern contains dynamic segments. */
+function isDynamic(pattern: string): boolean {
+  return pattern.includes(':');
+}
+
+/** Build the absolute URL for a route path. */
+function buildLoc(baseUrl: string, path: string, basePath = ''): string {
+  const base = baseUrl.replace(/\/+$/, '');
+  if (path === '/' && basePath) return `${base}${basePath}/`;
+  return `${base}${basePath}${path}`;
+}
+
+/**
+ * Expand a dynamic pattern using an enumerator's param values.
+ * Supports single-param patterns like '/projects/:id'.
+ * Multi-param patterns are expanded per value (first param replaced).
+ */
+function expandDynamic(pattern: string, values: string[]): string[] {
+  // Find the first :param segment
+  const paramMatch = pattern.match(/:([^/]+)/);
+  if (!paramMatch) return [];
+
+  return values.map((value) => pattern.replace(paramMatch[0], encodeURIComponent(value)));
+}
+
+/** Resolve route options: per-route override > defaults > empty. */
+function resolveOptions(
+  pattern: string,
+  options: SitemapOptions,
+): SitemapRouteOptions {
+  return { ...options.defaults, ...options.routes?.[pattern] };
+}
+
+/** Serialize a single <url> entry. */
+function serializeEntry(entry: SitemapEntry): string {
+  const lines = [`  <url>`, `    <loc>${escapeHtml(entry.loc)}</loc>`];
+
+  if (entry.lastmod !== undefined) {
+    lines.push(`    <lastmod>${escapeHtml(entry.lastmod)}</lastmod>`);
+  }
+  if (entry.changefreq !== undefined) {
+    lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);
+  }
+  if (entry.priority !== undefined) {
+    lines.push(`    <priority>${entry.priority.toFixed(1)}</priority>`);
+  }
+
+  lines.push(`  </url>`);
+  return lines.join('\n');
+}
+
+/**
+ * Generate sitemap.xml content from a routes manifest.
+ *
+ * Static routes (no :param) are included directly.
+ * Dynamic routes are included only if an enumerator is provided.
+ * All URLs point to /html/ prefixed paths for SSR HTML rendering.
+ */
+export async function generateSitemap(
+  manifest: RoutesManifest,
+  options: SitemapOptions,
+): Promise<string> {
+  const entries: SitemapEntry[] = [];
+  const bp = options.basePath ?? '';
+
+  // Filter to page routes only (exclude error, redirect)
+  const pages = manifest.routes.filter((r) => r.type === 'page');
+
+  for (const route of pages) {
+    const routeOpts = resolveOptions(route.pattern, options);
+
+    if (isDynamic(route.pattern)) {
+      // Dynamic route — use enumerator if provided, skip otherwise
+      const enumerator = options.enumerators?.[route.pattern];
+      if (!enumerator) continue;
+
+      const values = await enumerator();
+      const paths = expandDynamic(route.pattern, values);
+
+      for (const path of paths) {
+        entries.push({
+          loc: buildLoc(options.baseUrl, path, bp),
+          ...routeOpts,
+        });
+      }
+    } else {
+      // Static route — include directly
+      entries.push({
+        loc: buildLoc(options.baseUrl, route.pattern, bp),
+        ...routeOpts,
+      });
+    }
+
+    if (entries.length >= MAX_URLS) break;
+  }
+
+  const urlEntries = entries.slice(0, MAX_URLS).map(serializeEntry).join('\n');
+
+  return `${XML_HEADER}\n${URLSET_OPEN}\n${urlEntries}\n${URLSET_CLOSE}\n`;
+}