@emkodev/emroute 1.6.6-beta.2 → 1.6.6-beta.4

package/dist/emroute.js

@@ -0,0 +1,2757 @@
+// dist/src/util/html.util.js
+var SSR_ATTR = "ssr";
+var LAZY_ATTR = "lazy";
+var SsrShadowRoot = class {
+  host;
+  _innerHTML = "";
+  constructor(host) {
+    this.host = host;
+  }
+  get innerHTML() {
+    return this._innerHTML;
+  }
+  set innerHTML(value) {
+    this._innerHTML = value;
+  }
+  setHTMLUnsafe(html, _options) {
+    this._innerHTML = html;
+  }
+  append(..._nodes) {
+  }
+  querySelector(_selector) {
+    return null;
+  }
+  querySelectorAll(_selector) {
+    return [];
+  }
+  get childNodes() {
+    return [];
+  }
+  get firstChild() {
+    return null;
+  }
+};
+var SsrHTMLElement = class {
+  _innerHTML = "";
+  _shadowRoot = null;
+  _attributes = /* @__PURE__ */ new Map();
+  // Accept any CSS property assignment without error
+  style = new Proxy({}, {
+    set(_target, _prop, _value) {
+      return true;
+    },
+    get(_target, prop) {
+      if (typeof prop === "string")
+        return "";
+      return void 0;
+    }
+  });
+  get innerHTML() {
+    return this._innerHTML;
+  }
+  set innerHTML(value) {
+    this._innerHTML = value;
+  }
+  get shadowRoot() {
+    return this._shadowRoot;
+  }
+  get childNodes() {
+    return [];
+  }
+  get firstChild() {
+    return null;
+  }
+  get attributes() {
+    const attrs = [];
+    for (const [name, value] of this._attributes) {
+      attrs.push({ name, value });
+    }
+    return attrs;
+  }
+  attachShadow(_init) {
+    this._shadowRoot = new SsrShadowRoot(this);
+    return this._shadowRoot;
+  }
+  getAttribute(name) {
+    return this._attributes.get(name) ?? null;
+  }
+  setAttribute(name, value) {
+    this._attributes.set(name, value);
+  }
+  removeAttribute(name) {
+    this._attributes.delete(name);
+  }
+  hasAttribute(name) {
+    return this._attributes.has(name);
+  }
+  querySelector(_selector) {
+    return null;
+  }
+  querySelectorAll(_selector) {
+    return [];
+  }
+  append(..._nodes) {
+  }
+  appendChild(node) {
+    return node;
+  }
+};
+var HTMLElementBase = globalThis.HTMLElement ?? SsrHTMLElement;
+function escapeHtml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("`", "&#96;");
+}
+function unescapeHtml(text) {
+  return text.replaceAll("&#96;", "`").replaceAll("&#39;", "'").replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+}
+function scopeWidgetCss(css, widgetName) {
+  return `@scope (widget-${widgetName}) {
+${css}
+}`;
+}
+var STATUS_MESSAGES = {
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  500: "Internal Server Error"
+};
+
+// dist/src/element/slot.element.js
+var RouterSlot = class extends HTMLElementBase {
+};
+
+// dist/src/element/markdown.element.js
+var MarkdownElement = class _MarkdownElement extends HTMLElementBase {
+  static renderer = null;
+  static rendererInitPromise = null;
+  abortController = null;
+  /**
+   * Set the markdown renderer.
+   * Must be called before any <mark-down> elements are connected.
+   *
+   * @example
+   * ```ts
+   * import { createEmkoRenderer } from './emko.renderer.ts';
+   * MarkdownElement.setRenderer(await createEmkoRenderer());
+   * ```
+   */
+  static setRenderer(renderer) {
+    _MarkdownElement.renderer = renderer;
+    _MarkdownElement.rendererInitPromise = renderer.init ? renderer.init() : null;
+  }
+  /**
+   * Get the current renderer, waiting for init if needed.
+   */
+  static async getRenderer() {
+    const renderer = _MarkdownElement.renderer;
+    if (!renderer) {
+      throw new Error("No markdown renderer configured. Call MarkdownElement.setRenderer() before using <mark-down> elements.");
+    }
+    if (_MarkdownElement.rendererInitPromise) {
+      await _MarkdownElement.rendererInitPromise;
+    }
+    return renderer;
+  }
+  async connectedCallback() {
+    this.abortController = new AbortController();
+    await this.loadContent();
+  }
+  disconnectedCallback() {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+  async loadContent() {
+    const src = this.getAttribute("src");
+    const inlineContent = this.textContent?.trim();
+    if (src) {
+      await this.loadFromSrc(src);
+    } else if (inlineContent) {
+      await this.renderContent(inlineContent);
+    } else {
+      this.innerHTML = "";
+    }
+  }
+  async loadFromSrc(src) {
+    const signal = this.abortController?.signal;
+    try {
+      const response = await fetch(src, { signal });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${src}: ${response.status}`);
+      }
+      const markdown = await response.text();
+      await this.renderContent(markdown);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      this.showError(error);
+    }
+  }
+  async renderContent(markdown) {
+    try {
+      const renderer = await _MarkdownElement.getRenderer();
+      this.innerHTML = renderer.render(markdown);
+    } catch (error) {
+      this.showError(error);
+    }
+  }
+  showError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    this.innerHTML = `<div>Markdown Error: ${escapeHtml(message)}</div>`;
+  }
+};
+
+// dist/src/element/component.element.js
+var ComponentElement = class _ComponentElement extends HTMLElementBase {
+  /** Shared file content cache — deduplicates fetches across all widget instances. */
+  static fileCache = /* @__PURE__ */ new Map();
+  /** App-level context provider set once during router initialization. */
+  static extendContext;
+  /** Register (or clear) the context provider that enriches every widget's ComponentContext. */
+  static setContextProvider(provider) {
+    _ComponentElement.extendContext = provider;
+  }
+  component;
+  effectiveFiles;
+  params = null;
+  data = null;
+  context;
+  state = "idle";
+  errorMessage = "";
+  deferred = null;
+  abortController = null;
+  intersectionObserver = null;
+  /** Promise that resolves with fetched data (available after loadData starts) */
+  dataPromise = null;
+  constructor(component, files) {
+    super();
+    this.component = component;
+    this.effectiveFiles = files;
+    if (!this.shadowRoot) {
+      this.attachShadow({ mode: "open" });
+    }
+  }
+  /**
+   * Register a widget as a custom element: `widget-{name}`.
+   * Creates a fresh widget instance per DOM element (per-element state).
+   * Optional `files` parameter provides discovered file paths without mutating
+   * the component instance.
+   */
+  static register(component, files) {
+    const tagName = `widget-${component.name}`;
+    if (!globalThis.customElements || customElements.get(tagName)) {
+      return;
+    }
+    const WidgetClass = component.constructor;
+    const BoundElement = class extends _ComponentElement {
+      constructor() {
+        super(new WidgetClass(), files);
+      }
+    };
+    customElements.define(tagName, BoundElement);
+  }
+  /**
+   * Register a widget class (not instance) as a custom element: `widget-{name}`.
+   * Used for manifest-based registration where classes are loaded dynamically.
+   */
+  static registerClass(WidgetClass, name, files) {
+    const tagName = `widget-${name}`;
+    if (!globalThis.customElements || customElements.get(tagName)) {
+      return;
+    }
+    const BoundElement = class extends _ComponentElement {
+      constructor() {
+        super(new WidgetClass(), files);
+      }
+    };
+    customElements.define(tagName, BoundElement);
+  }
+  /**
+   * Promise that resolves when component is ready (data loaded and rendered).
+   * Used by router to wait for async components.
+   */
+  get ready() {
+    if (this.state === "ready") {
+      return Promise.resolve();
+    }
+    this.deferred ??= Promise.withResolvers();
+    return this.deferred.promise;
+  }
+  async connectedCallback() {
+    this.component.element = this;
+    this.style.contentVisibility = "auto";
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    const params = {};
+    for (const attr of this.attributes) {
+      if (attr.name === SSR_ATTR || attr.name === LAZY_ATTR)
+        continue;
+      const key = attr.name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      try {
+        params[key] = JSON.parse(attr.value);
+      } catch {
+        params[key] = attr.value;
+      }
+    }
+    this.params = params;
+    if (this.component.validateParams && this.params !== null) {
+      const error = this.component.validateParams(this.params);
+      if (error) {
+        this.setError(error);
+        return;
+      }
+    }
+    const files = await this.loadFiles();
+    if (signal.aborted)
+      return;
+    const currentUrl = globalThis.location ? new URL(location.href) : new URL("http://localhost/");
+    const base = {
+      url: currentUrl,
+      pathname: currentUrl.pathname,
+      searchParams: currentUrl.searchParams,
+      params: this.params ?? {},
+      files: files.html || files.md || files.css ? files : void 0
+    };
+    this.context = _ComponentElement.extendContext ? _ComponentElement.extendContext(base) : base;
+    if (this.hasAttribute(SSR_ATTR)) {
+      this.removeAttribute(SSR_ATTR);
+      const lightText = this.textContent?.trim();
+      if (lightText) {
+        try {
+          this.data = JSON.parse(lightText);
+        } catch {
+        }
+      }
+      this.textContent = "";
+      this.state = "ready";
+      if (this.component.hydrate) {
+        const args = { data: this.data, params: this.params, context: this.context };
+        queueMicrotask(() => {
+          this.component.hydrate(args);
+        });
+      }
+      this.signalReady();
+      return;
+    }
+    if (this.hasAttribute(LAZY_ATTR)) {
+      this.intersectionObserver = new IntersectionObserver(([entry]) => {
+        if (entry.isIntersecting) {
+          this.intersectionObserver?.disconnect();
+          this.intersectionObserver = null;
+          this.loadData();
+        }
+      });
+      this.intersectionObserver.observe(this);
+      return;
+    }
+    await this.loadData();
+  }
+  disconnectedCallback() {
+    this.component.destroy?.();
+    this.component.element = void 0;
+    this.intersectionObserver?.disconnect();
+    this.intersectionObserver = null;
+    this.abortController?.abort();
+    this.abortController = null;
+    this.state = "idle";
+    this.data = null;
+    this.context = void 0;
+    this.dataPromise = null;
+    this.errorMessage = "";
+    this.signalReady();
+    this.deferred = null;
+  }
+  /**
+   * Reload component data. Aborts any in-flight request first.
+   */
+  async reload() {
+    if (this.params === null)
+      return;
+    this.abortController?.abort();
+    this.abortController = new AbortController();
+    await this.loadData();
+  }
+  /**
+   * Fetch a single file by path, with caching.
+   * Absolute URLs (http/https) pass through; relative paths get '/' prefix.
+   */
+  static loadFile(path) {
+    const cached = _ComponentElement.fileCache.get(path);
+    if (cached)
+      return cached;
+    const url = path.startsWith("http://") || path.startsWith("https://") ? path : path.startsWith("/") ? path : "/" + path;
+    const promise = fetch(url).then((res) => res.ok ? res.text() : void 0, () => void 0);
+    _ComponentElement.fileCache.set(path, promise);
+    return promise;
+  }
+  /**
+   * Load all companion files for this widget instance.
+   * Uses effectiveFiles (from registration) falling back to component.files.
+   */
+  async loadFiles() {
+    const filePaths = this.effectiveFiles ?? this.component.files;
+    if (!filePaths)
+      return {};
+    const [html, md, css] = await Promise.all([
+      filePaths.html ? _ComponentElement.loadFile(filePaths.html) : void 0,
+      filePaths.md ? _ComponentElement.loadFile(filePaths.md) : void 0,
+      filePaths.css ? _ComponentElement.loadFile(filePaths.css) : void 0
+    ]);
+    return { html, md, css };
+  }
+  async loadData() {
+    if (this.params === null)
+      return;
+    const signal = this.abortController?.signal;
+    this.state = "loading";
+    this.render();
+    try {
+      const promise = this.component.getData({
+        params: this.params,
+        signal,
+        context: this.context
+      });
+      this.dataPromise = promise;
+      this.data = await promise;
+      if (signal?.aborted)
+        return;
+      this.state = "ready";
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError")
+        return;
+      if (signal?.aborted)
+        return;
+      this.setError(e instanceof Error ? e.message : String(e));
+      return;
+    }
+    this.render();
+    this.signalReady();
+  }
+  setError(message) {
+    this.state = "error";
+    this.errorMessage = message;
+    this.render();
+    this.signalReady();
+  }
+  signalReady() {
+    this.deferred?.resolve();
+    this.deferred = null;
+  }
+  render() {
+    if (this.params === null) {
+      this.shadowRoot.setHTMLUnsafe("");
+      return;
+    }
+    if (this.state === "error") {
+      this.shadowRoot.setHTMLUnsafe(this.component.renderError({
+        error: new Error(this.errorMessage),
+        params: this.params
+      }));
+      return;
+    }
+    this.shadowRoot.setHTMLUnsafe(this.component.renderHTML({
+      data: this.state === "ready" ? this.data : null,
+      params: this.params,
+      context: this.context
+    }));
+    if (this.state === "ready" && this.component.hydrate) {
+      const args = { data: this.data, params: this.params, context: this.context };
+      queueMicrotask(() => {
+        this.component.hydrate(args);
+      });
+    }
+  }
+};
+
+// dist/src/widget/widget.registry.js
+var WidgetRegistry = class {
+  widgets = /* @__PURE__ */ new Map();
+  /** Register a widget by its name. */
+  add(widget) {
+    this.widgets.set(widget.name, widget);
+  }
+  /** Look up a widget by name. */
+  get(name) {
+    return this.widgets.get(name);
+  }
+  /** Iterate all registered widgets. */
+  [Symbol.iterator]() {
+    return this.widgets.values();
+  }
+  /** Emit a WidgetsManifest from registered widgets. */
+  toManifest() {
+    const widgets = [];
+    const moduleLoaders = {};
+    for (const [name, widget] of this.widgets) {
+      const entry = {
+        name,
+        modulePath: name,
+        tagName: `widget-${name}`,
+        files: widget.files
+      };
+      widgets.push(entry);
+      moduleLoaders[name] = () => Promise.resolve({ default: widget.constructor });
+    }
+    return { widgets, moduleLoaders };
+  }
+};
+
+// dist/src/route/route.core.js
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+  if (typeof path === "string" && /^\.\.?\//.test(path)) {
+    return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+    });
+  }
+  return path;
+};
+var DEFAULT_BASE_PATH = { html: "/html", md: "/md", app: "/app" };
+var BLOCKED_PROTOCOLS = /^(javascript|data|vbscript):/i;
+function assertSafeRedirect(url) {
+  if (BLOCKED_PROTOCOLS.test(url.trim())) {
+    throw new Error(`Unsafe redirect URL blocked: ${url}`);
+  }
+}
+var DEFAULT_ROOT_ROUTE = {
+  pattern: "/",
+  type: "page",
+  modulePath: "__default_root__"
+};
+function toRouteConfig(resolved) {
+  const node = resolved.node;
+  return {
+    pattern: resolved.pattern,
+    type: node.redirect ? "redirect" : "page",
+    modulePath: node.redirect ?? node.files?.ts ?? node.files?.js ?? node.files?.html ?? node.files?.md ?? "",
+    files: node.files
+  };
+}
+var RouteCore = class {
+  resolver;
+  /** Registered context provider (if any). Exposed so renderers can apply it to inline contexts. */
+  contextProvider;
+  listeners = /* @__PURE__ */ new Set();
+  moduleCache = /* @__PURE__ */ new Map();
+  widgetFileCache = /* @__PURE__ */ new Map();
+  moduleLoaders;
+  currentRoute = null;
+  readFile;
+  constructor(resolver, options = {}) {
+    this.resolver = resolver;
+    this.readFile = options.fileReader ?? ((path) => fetch(path, { headers: { Accept: "text/plain" } }).then((r) => r.text()));
+    this.contextProvider = options.extendContext;
+    this.moduleLoaders = options.moduleLoaders ?? {};
+  }
+  /**
+   * Get current route parameters.
+   */
+  getParams() {
+    return this.currentRoute?.params ?? {};
+  }
+  /**
+   * Add event listener for router events.
+   */
+  addEventListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Emit router event to listeners.
+   */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (e) {
+        console.error("[Router] Event listener error:", e);
+      }
+    }
+  }
+  /**
+   * Match a URL to a route.
+   * Falls back to the default root route for '/'.
+   */
+  match(url) {
+    const pathname = url.pathname;
+    const resolved = this.resolver.match(pathname);
+    if (resolved) {
+      return {
+        route: toRouteConfig(resolved),
+        params: resolved.params
+      };
+    }
+    if (pathname === "/" || pathname === "") {
+      return {
+        route: DEFAULT_ROOT_ROUTE,
+        params: {}
+      };
+    }
+    return void 0;
+  }
+  /** Get status-specific page (404, 401, 403). */
+  getStatusPage(status) {
+    const node = this.resolver.findRoute(`/${status}`);
+    if (!node)
+      return void 0;
+    return {
+      pattern: `/${status}`,
+      type: "page",
+      modulePath: node.files?.ts ?? node.files?.js ?? node.files?.html ?? node.files?.md ?? "",
+      files: node.files
+    };
+  }
+  /** Get global error handler (root errorBoundary). */
+  getErrorHandler() {
+    const modulePath = this.resolver.findErrorBoundary("/");
+    if (!modulePath)
+      return void 0;
+    return { pattern: "/", type: "error", modulePath };
+  }
+  /**
+   * Find error boundary for a given pathname.
+   * Note: pattern is the input pathname, not the boundary's own pattern.
+   * Callers should only rely on modulePath.
+   */
+  findErrorBoundary(pathname) {
+    const modulePath = this.resolver.findErrorBoundary(pathname);
+    if (!modulePath)
+      return void 0;
+    return { pattern: pathname, modulePath };
+  }
+  /**
+   * Find a route by its exact pattern.
+   * Used for building route hierarchy.
+   */
+  findRoute(pattern) {
+    const node = this.resolver.findRoute(pattern);
+    if (!node)
+      return void 0;
+    return {
+      pattern,
+      type: node.redirect ? "redirect" : "page",
+      modulePath: node.redirect ?? node.files?.ts ?? node.files?.js ?? node.files?.html ?? node.files?.md ?? "",
+      files: node.files
+    };
+  }
+  /**
+   * Build route hierarchy from a pattern.
+   * Patterns are always unprefixed (no basePath).
+   *
+   * e.g., '/projects/:id/tasks'
+   *   → ['/', '/projects', '/projects/:id', '/projects/:id/tasks']
+   */
+  buildRouteHierarchy(pattern) {
+    if (pattern === "/") {
+      return ["/"];
+    }
+    const segments = pattern.split("/").filter(Boolean);
+    const hierarchy = ["/"];
+    let current = "";
+    for (const segment of segments) {
+      current += "/" + segment;
+      hierarchy.push(current);
+    }
+    return hierarchy;
+  }
+  /**
+   * Normalize URL by removing trailing slashes (except bare '/').
+   */
+  normalizeUrl(url) {
+    if (url.length > 1 && url.endsWith("/")) {
+      return url.slice(0, -1);
+    }
+    return url;
+  }
+  /**
+   * Convert relative path to absolute path.
+   */
+  toAbsolutePath(path) {
+    return path.startsWith("/") ? path : "/" + path;
+  }
+  /**
+   * Load a module with caching.
+   * Uses pre-bundled loaders when available, falls back to dynamic import.
+   */
+  async loadModule(modulePath) {
+    if (this.moduleCache.has(modulePath)) {
+      return this.moduleCache.get(modulePath);
+    }
+    let module;
+    const loader = this.moduleLoaders[modulePath];
+    if (loader) {
+      module = await loader();
+    } else {
+      const absolutePath = this.toAbsolutePath(modulePath);
+      module = await import(__rewriteRelativeImportExtension(absolutePath));
+    }
+    this.moduleCache.set(modulePath, module);
+    return module;
+  }
+  /**
+   * Load widget file contents with caching.
+   */
+  async loadWidgetFiles(widgetFiles) {
+    const load = async (path) => {
+      const absPath = this.toAbsolutePath(path);
+      const cached = this.widgetFileCache.get(absPath);
+      if (cached !== void 0)
+        return cached;
+      try {
+        const content = await this.readFile(absPath);
+        this.widgetFileCache.set(absPath, content);
+        return content;
+      } catch (e) {
+        console.warn(`[RouteCore] Failed to load widget file ${path}:`, e instanceof Error ? e.message : e);
+        return void 0;
+      }
+    };
+    const [html, md, css] = await Promise.all([
+      widgetFiles.html ? load(widgetFiles.html) : void 0,
+      widgetFiles.md ? load(widgetFiles.md) : void 0,
+      widgetFiles.css ? load(widgetFiles.css) : void 0
+    ]);
+    return { html, md, css };
+  }
+  /**
+   * Build a RouteInfo from a matched route and the resolved URL pathname.
+   * Called once per navigation; the result is reused across the route hierarchy.
+   */
+  toRouteInfo(matched, url) {
+    return {
+      url,
+      params: matched.params
+    };
+  }
+  /**
+   * Get inlined `__files` from a cached module (merged module pattern).
+   * Returns undefined if the module isn't cached or has no __files.
+   */
+  getModuleFiles(modulePath) {
+    const cached = this.moduleCache.get(modulePath);
+    if (!cached || typeof cached !== "object")
+      return void 0;
+    const files = cached.__files;
+    if (!files || typeof files !== "object")
+      return void 0;
+    return files;
+  }
+  /**
+   * Build a ComponentContext by extending RouteInfo with loaded file contents.
+   *
+   * When the route module is a merged module (contains `__files`), uses
+   * inlined content directly. Otherwise falls back to reading companion files.
+   */
+  async buildComponentContext(routeInfo, route, signal, isLeaf) {
+    const rf = route.files;
+    const modulePath = rf?.ts ?? rf?.js;
+    const inlined = modulePath ? this.getModuleFiles(modulePath) : void 0;
+    let html;
+    let md;
+    let css;
+    if (inlined) {
+      html = inlined.html;
+      md = inlined.md;
+      css = inlined.css;
+    } else {
+      const fetchFile = (filePath) => this.readFile(this.toAbsolutePath(filePath));
+      [html, md, css] = await Promise.all([
+        rf?.html ? fetchFile(rf.html) : void 0,
+        rf?.md ? fetchFile(rf.md) : void 0,
+        rf?.css ? fetchFile(rf.css) : void 0
+      ]);
+    }
+    const base = {
+      ...routeInfo,
+      pathname: routeInfo.url.pathname,
+      searchParams: routeInfo.url.searchParams,
+      files: { html, md, css },
+      signal,
+      isLeaf
+    };
+    return this.contextProvider ? this.contextProvider(base) : base;
+  }
+};
+
+// dist/src/renderer/spa/thin-client.js
+var EmrouteApp = class {
+  server;
+  appBase;
+  slot = null;
+  abortController = null;
+  constructor(server, options) {
+    const bp = options?.basePath ?? DEFAULT_BASE_PATH;
+    this.server = server;
+    this.appBase = bp.app;
+  }
+  async initialize(slotSelector = "router-slot") {
+    this.slot = document.querySelector(slotSelector);
+    if (!this.slot) {
+      console.error("[EmrouteApp] Slot not found:", slotSelector);
+      return;
+    }
+    if (!("navigation" in globalThis)) {
+      console.warn("[EmrouteApp] Navigation API not available");
+      return;
+    }
+    this.abortController = new AbortController();
+    const { signal } = this.abortController;
+    navigation.addEventListener("navigate", (event) => {
+      if (!event.canIntercept)
+        return;
+      if (event.hashChange)
+        return;
+      if (event.downloadRequest !== null)
+        return;
+      const url = new URL(event.destination.url);
+      if (!this.isAppPath(url.pathname))
+        return;
+      event.intercept({
+        scroll: "manual",
+        handler: async () => {
+          await this.handleNavigation(url, event.signal);
+          event.scroll();
+        }
+      });
+    }, { signal });
+    const ssrRoute = this.slot.getAttribute("data-ssr-route");
+    if (ssrRoute && (location.pathname === ssrRoute || location.pathname === ssrRoute + "/")) {
+      this.slot.removeAttribute("data-ssr-route");
+      return;
+    }
+    await this.handleNavigation(new URL(location.href), this.abortController.signal);
+  }
+  dispose() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.slot = null;
+  }
+  async navigate(url, options = {}) {
+    try {
+      const { finished } = navigation.navigate(url, {
+        state: options.state,
+        history: options.replace ? "replace" : "auto"
+      });
+      await finished;
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError")
+        return;
+      throw e;
+    }
+  }
+  isAppPath(pathname) {
+    return pathname === this.appBase || pathname.startsWith(this.appBase + "/");
+  }
+  stripAppBase(pathname) {
+    if (pathname === this.appBase)
+      return "/";
+    if (pathname.startsWith(this.appBase + "/"))
+      return pathname.slice(this.appBase.length);
+    return pathname;
+  }
+  async handleNavigation(url, signal) {
+    if (!this.slot || !this.server.htmlRouter)
+      return;
+    const routePath = this.stripAppBase(url.pathname);
+    const routeUrl = new URL(routePath + url.search, url.origin);
+    try {
+      const { content, title, redirect } = await this.server.htmlRouter.render(routeUrl, signal);
+      if (signal.aborted)
+        return;
+      if (redirect) {
+        assertSafeRedirect(redirect);
+        const target = redirect.startsWith("/") ? this.appBase + redirect : redirect;
+        navigation.navigate(target, { history: "replace" });
+        return;
+      }
+      if (document.startViewTransition) {
+        const transition = document.startViewTransition(() => {
+          this.slot.setHTMLUnsafe(content);
+        });
+        signal.addEventListener("abort", () => transition.skipTransition(), { once: true });
+        await transition.updateCallbackDone;
+      } else {
+        this.slot.setHTMLUnsafe(content);
+      }
+      if (title)
+        document.title = title;
+    } catch (error) {
+      if (signal.aborted)
+        return;
+      console.error("[EmrouteApp] Navigation error:", error);
+      if (this.slot) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.slot.setHTMLUnsafe(`<h1>Error</h1><p>${escapeHtml(message)}</p>`);
+      }
+    }
+  }
+};
+async function createEmrouteApp(server, options) {
+  const g = globalThis;
+  if (g.__emroute_app) {
+    console.warn("eMroute: App already initialized.");
+    return g.__emroute_app;
+  }
+  const app = new EmrouteApp(server, options);
+  await app.initialize();
+  g.__emroute_app = app;
+  return app;
+}
+
+// dist/src/component/abstract.component.js
+var Component = class {
+  /** Host element reference, set by ComponentElement in the browser. */
+  element;
+  /** Associated file paths for pre-loaded content (html, md, css). */
+  files;
+  /**
+   * When true, SSR serializes the getData() result into the element's
+   * light DOM so the client can access it immediately in hydrate()
+   * without re-fetching.
+   *
+   * Default is false — hydrate() receives `data: null`. Most widgets
+   * don't need this because the rendered Shadow DOM already contains
+   * the visual representation of the data.
+   *
+   * If you find yourself parsing the shadow DOM in hydrate() trying to
+   * reconstruct the original data object, set this to true instead.
+   * The server-fetched data will be available as `args.data` in hydrate().
+   */
+  exposeSsrData;
+  /**
+   * Render as HTML for browser context.
+   *
+   * Default implementation converts renderMarkdown() output to HTML.
+   * Override for custom HTML rendering with rich styling/interactivity.
+   */
+  renderHTML(args) {
+    if (args.data === null) {
+      return `<div data-component="${this.name}">Loading...</div>`;
+    }
+    const markdown = this.renderMarkdown({
+      data: args.data,
+      params: args.params,
+      context: args.context
+    });
+    return `<div data-component="${this.name}" data-markdown>${escapeHtml(markdown)}</div>`;
+  }
+  /**
+   * Render error state.
+   */
+  renderError(args) {
+    const msg = args.error instanceof Error ? args.error.message : String(args.error);
+    return `<div data-component="${this.name}">Error: ${escapeHtml(msg)}</div>`;
+  }
+  /**
+   * Render error as markdown.
+   */
+  renderMarkdownError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return `> **Error** (\`${this.name}\`): ${msg}`;
+  }
+};
+
+// dist/src/component/page.component.js
+var PageComponent = class extends Component {
+  name = "page";
+  /** Route pattern this page handles (optional — set by subclasses) */
+  pattern;
+  /**
+   * Fetch or compute page data. Override in subclasses.
+   * Default: returns null (no data needed).
+   *
+   * @example
+   * ```ts
+   * override getData({ params, context }: this['DataArgs']) {
+   *   return fetch(`/api/${params.id}`, { signal: context?.signal });
+   * }
+   * ```
+   */
+  getData(_args) {
+    return Promise.resolve(null);
+  }
+  /**
+   * Render page as HTML.
+   *
+   * Fallback chain:
+   * 1. html file content from context
+   * 2. md file content wrapped in `<mark-down>`
+   * 3. `<router-slot />` (bare slot for child routes)
+   *
+   * @example
+   * ```ts
+   * override renderHTML({ data, params, context }: this['RenderArgs']) {
+   *   return `<h1>${params.id}</h1><p>${context?.files?.html ?? ''}</p>`;
+   * }
+   * ```
+   */
+  renderHTML(args) {
+    const files = args.context.files;
+    const style = files?.css ? `<style>${files.css}</style>
+` : "";
+    if (files?.html) {
+      let html = style + files.html;
+      if (files.md && html.includes("<mark-down></mark-down>")) {
+        html = html.replace("<mark-down></mark-down>", `<mark-down>${escapeHtml(files.md)}</mark-down>`);
+      }
+      return html;
+    }
+    if (files?.md) {
+      const hasSlot = files.md.includes("```router-slot");
+      const slot = args.context.isLeaf || hasSlot ? "" : "\n<router-slot></router-slot>";
+      return `${style}<mark-down>${escapeHtml(files.md)}</mark-down>${slot}`;
+    }
+    return args.context.isLeaf ? "" : "<router-slot></router-slot>";
+  }
+  /**
+   * Render page as Markdown.
+   *
+   * Fallback chain:
+   * 1. md file content from context
+   * 2. `` ```router-slot\n``` `` (slot placeholder in markdown — newline required)
+   *
+   * @example
+   * ```ts
+   * override renderMarkdown({ data, params, context }: this['RenderArgs']) {
+   *   return `# ${params.id}\n\n${context?.files?.md ?? ''}`;
+   * }
+   * ```
+   */
+  renderMarkdown(args) {
+    const files = args.context.files;
+    if (files?.md) {
+      return files.md;
+    }
+    return args.context.isLeaf ? "" : "```router-slot\n```";
+  }
+  /**
+   * Page title. Override in subclasses.
+   * Default: undefined (no title).
+   *
+   * @example
+   * ```ts
+   * override getTitle({ data, params }: this['RenderArgs']) {
+   *   return `Project ${params.id}`;
+   * }
+   * ```
+   */
+  getTitle(_args) {
+    return void 0;
+  }
+};
+var page_component_default = new PageComponent();
+
+// dist/src/component/widget.component.js
+var WidgetComponent = class extends Component {
+  /**
+   * Render widget as HTML.
+   *
+   * Fallback chain:
+   * 1. html file content from context
+   * 2. md file content wrapped in `<mark-down>`
+   * 3. base Component default (markdown→HTML conversion)
+   *
+   * @example
+   * ```ts
+   * override renderHTML({ data, params }: this['RenderArgs']) {
+   *   return `<span>${params.coin}: $${data?.price}</span>`;
+   * }
+   * ```
+   */
+  renderHTML(args) {
+    const files = args.context.files;
+    const style = files?.css ? `<style>${scopeWidgetCss(files.css, this.name)}</style>
+` : "";
+    if (files?.html) {
+      return style + files.html;
+    }
+    if (files?.md) {
+      return `${style}<mark-down>${escapeHtml(files.md)}</mark-down>`;
+    }
+    if (style) {
+      return style + super.renderHTML(args);
+    }
+    return super.renderHTML(args);
+  }
+  /**
+   * Render widget as Markdown.
+   *
+   * Fallback chain:
+   * 1. md file content from context
+   * 2. empty string
+   *
+   * @example
+   * ```ts
+   * override renderMarkdown({ data, params }: this['RenderArgs']) {
+   *   return `**${params.coin}**: $${data?.price}`;
+   * }
+   * ```
+   */
+  renderMarkdown(args) {
+    const files = args.context.files;
+    if (files?.md) {
+      return files.md;
+    }
+    return "";
+  }
+};
+
+// dist/src/route/route.trie.js
+function createNode() {
+  return { static: /* @__PURE__ */ new Map() };
+}
+function safeDecode(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function splitSegments(pathname) {
+  return pathname.substring(1).split("/");
+}
+function convertNode(source, pattern) {
+  const node = createNode();
+  if (source.files || source.redirect) {
+    node.route = source;
+    node.pattern = pattern;
+  }
+  if (source.errorBoundary) {
+    node.errorBoundary = source.errorBoundary;
+  }
+  if (source.children) {
+    for (const [segment, child] of Object.entries(source.children)) {
+      const childPattern = pattern === "/" ? `/${segment}` : `${pattern}/${segment}`;
+      node.static.set(segment, convertNode(child, childPattern));
+    }
+  }
+  if (source.dynamic) {
+    const { param, child } = source.dynamic;
+    const childPattern = pattern === "/" ? `/:${param}` : `${pattern}/:${param}`;
+    node.dynamic = { param, node: convertNode(child, childPattern) };
+  }
+  if (source.wildcard) {
+    const { param, child } = source.wildcard;
+    const childPattern = pattern === "/" ? `/:${param}*` : `${pattern}/:${param}*`;
+    node.wildcard = { param, node: convertNode(child, childPattern) };
+  }
+  return node;
+}
+var RouteTrie = class {
+  root;
+  constructor(tree) {
+    this.root = convertNode(tree, "/");
+  }
+  match(pathname) {
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+    if (!pathname.startsWith("/")) {
+      pathname = "/" + pathname;
+    }
+    if (pathname === "/") {
+      if (this.root.route) {
+        return { node: this.root.route, pattern: "/", params: {} };
+      }
+      return void 0;
+    }
+    const segments = splitSegments(pathname);
+    return this.walk(this.root, segments, 0, {});
+  }
+  findErrorBoundary(pathname) {
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+    if (!pathname.startsWith("/")) {
+      pathname = "/" + pathname;
+    }
+    if (pathname === "/")
+      return this.root.errorBoundary;
+    const segments = splitSegments(pathname);
+    return this.walkForBoundary(this.root, segments, 0, this.root.errorBoundary);
+  }
+  findRoute(pattern) {
+    if (pattern === "/") {
+      return this.root.route;
+    }
+    const segments = splitSegments(pattern);
+    let node = this.root;
+    for (const segment of segments) {
+      let child;
+      if (segment.startsWith(":") && segment.endsWith("*")) {
+        child = node.wildcard?.node;
+      } else if (segment.startsWith(":")) {
+        child = node.dynamic?.node;
+      } else {
+        child = node.static.get(segment);
+      }
+      if (!child)
+        return void 0;
+      node = child;
+    }
+    return node.route;
+  }
+  // ── Private matching ──────────────────────────────────────────────────
+  walk(node, segments, index, params) {
+    if (index === segments.length) {
+      if (node.route) {
+        return { node: node.route, pattern: node.pattern, params: { ...params } };
+      }
+      if (node.wildcard?.node.route) {
+        return {
+          node: node.wildcard.node.route,
+          pattern: node.wildcard.node.pattern,
+          params: { ...params, [node.wildcard.param]: "" }
+        };
+      }
+      return void 0;
+    }
+    const segment = segments[index];
+    const staticChild = node.static.get(segment);
+    if (staticChild) {
+      const result = this.walk(staticChild, segments, index + 1, params);
+      if (result)
+        return result;
+    }
+    if (node.dynamic) {
+      const { param, node: dynamicNode } = node.dynamic;
+      params[param] = safeDecode(segment);
+      const result = this.walk(dynamicNode, segments, index + 1, params);
+      if (result)
+        return result;
+      delete params[param];
+    }
+    if (node.wildcard?.node.route) {
+      const { param, node: wildcardNode } = node.wildcard;
+      let rest = safeDecode(segments[index]);
+      for (let i = index + 1; i < segments.length; i++) {
+        rest += "/" + safeDecode(segments[i]);
+      }
+      return {
+        node: wildcardNode.route,
+        pattern: wildcardNode.pattern,
+        params: { ...params, [param]: rest }
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Walk for error boundary. Follows the same priority as match
+   * (static → dynamic → wildcard) without backtracking across branches.
+   * Returns the deepest error boundary module path found along the path.
+   */
+  walkForBoundary(node, segments, index, deepest) {
+    if (index === segments.length) {
+      return node.errorBoundary ?? deepest;
+    }
+    const segment = segments[index];
+    const staticChild = node.static.get(segment);
+    if (staticChild) {
+      return this.walkForBoundary(staticChild, segments, index + 1, staticChild.errorBoundary ?? deepest);
+    }
+    if (node.dynamic) {
+      return this.walkForBoundary(node.dynamic.node, segments, index + 1, node.dynamic.node.errorBoundary ?? deepest);
+    }
+    if (node.wildcard) {
+      return node.wildcard.node.errorBoundary ?? deepest;
+    }
+    return deepest;
+  }
+};
+
+// dist/src/type/logger.type.js
+var noop = () => {
+};
+var logger = { error: noop, warn: noop };
+function setLogger(impl) {
+  logger.error = impl.error.bind(impl);
+  logger.warn = impl.warn.bind(impl);
+}
+
+// dist/src/overlay/overlay.css.js
+var overlayCSS = (
+  /* css */
+  `
+:root {
+  --overlay-backdrop: oklch(0% 0 0 / 0.5);
+  --overlay-surface: oklch(100% 0 0);
+  --overlay-radius: 8px;
+  --overlay-shadow: 0 8px 32px oklch(0% 0 0 / 0.2);
+  --overlay-toast-gap: 8px;
+  --overlay-toast-duration: 5s;
+  --overlay-z: 1000;
+}
+
+/* --- Modal (dialog) --- */
+
+dialog[data-overlay-modal] {
+  border: none;
+  padding: 0;
+  background: var(--overlay-surface);
+  border-radius: var(--overlay-radius);
+  box-shadow: var(--overlay-shadow);
+  max-width: min(90vw, 560px);
+  max-height: 85vh;
+  overflow: auto;
+  opacity: 1;
+  translate: 0 0;
+  transition:
+    opacity 200ms,
+    translate 200ms;
+}
+
+dialog[data-overlay-modal][open] {
+  transition:
+    opacity 200ms,
+    translate 200ms,
+    display 200ms allow-discrete,
+    overlay 200ms allow-discrete;
+
+  @starting-style {
+    opacity: 0;
+    translate: 0 20px;
+  }
+}
+
+dialog[data-overlay-modal]::backdrop {
+  background: var(--overlay-backdrop);
+  opacity: 1;
+  transition: opacity 200ms;
+}
+
+dialog[data-overlay-modal][open]::backdrop {
+  transition:
+    opacity 200ms,
+    display 200ms allow-discrete,
+    overlay 200ms allow-discrete;
+
+  @starting-style {
+    opacity: 0;
+  }
+}
+
+dialog[data-overlay-modal][data-dismissing] {
+  opacity: 0;
+  translate: 0 20px;
+}
+
+dialog[data-overlay-modal][data-dismissing]::backdrop {
+  opacity: 0;
+}
+
+/* --- Toast container --- */
+
+[data-overlay-toast-container] {
+  position: fixed;
+  bottom: 16px;
+  right: 16px;
+  z-index: var(--overlay-z);
+  display: flex;
+  flex-direction: column;
+  gap: var(--overlay-toast-gap);
+  pointer-events: none;
+}
+
+/* --- Toast item --- */
+
+[data-overlay-toast] {
+  pointer-events: auto;
+  background: var(--overlay-surface);
+  border-radius: var(--overlay-radius);
+  box-shadow: var(--overlay-shadow);
+  padding: 12px 16px;
+  animation: overlay-toast-auto var(--overlay-toast-duration, 5s) ease-in-out forwards;
+}
+
+/* Manual toast (timeout: 0): no auto-dismiss, entry transition only */
+[data-overlay-toast][data-toast-manual] {
+  animation: none;
+  opacity: 1;
+  translate: 0 0;
+  transition:
+    opacity 200ms,
+    translate 200ms;
+
+  @starting-style {
+    opacity: 0;
+    translate: 20px 0;
+  }
+}
+
+/* Dismissed toast: CSS exit animation */
+[data-overlay-toast][data-dismissing] {
+  animation: overlay-toast-exit 200ms ease-in forwards;
+}
+
+@keyframes overlay-toast-auto {
+  0%   { opacity: 0; translate: 20px 0; }
+  10%  { opacity: 1; translate: 0 0; }
+  80%  { opacity: 1; translate: 0 0; }
+  100% { opacity: 0; translate: 0 0; display: none; }
+}
+
+@keyframes overlay-toast-exit {
+  to { opacity: 0; translate: 20px 0; display: none; }
+}
+
+/* --- Popover --- */
+
+[data-overlay-popover] {
+  border: none;
+  padding: 0;
+  margin: 0;
+  background: var(--overlay-surface);
+  border-radius: var(--overlay-radius);
+  box-shadow: var(--overlay-shadow);
+  opacity: 1;
+  scale: 1;
+  transition:
+    opacity 200ms,
+    scale 200ms;
+}
+
+[data-overlay-popover]:popover-open {
+  position-anchor: auto;
+  inset: unset;
+  top: anchor(bottom);
+  left: anchor(start);
+  margin-top: 4px;
+  transition:
+    opacity 200ms,
+    scale 200ms,
+    display 200ms allow-discrete,
+    overlay 200ms allow-discrete;
+
+  @starting-style {
+    opacity: 0;
+    scale: 0.95;
+  }
+}
+
+[data-overlay-popover][data-dismissing] {
+  opacity: 0;
+  scale: 0.95;
+}
+`
+);
+
+// dist/src/overlay/overlay.service.js
+var ANIMATION_SAFETY_TIMEOUT = 300;
+function animateDismiss(el, onDone) {
+  el.setAttribute("data-dismissing", "");
+  let done = false;
+  const finish = () => {
+    if (done)
+      return;
+    done = true;
+    onDone();
+  };
+  el.addEventListener("transitionend", finish, { once: true });
+  setTimeout(finish, ANIMATION_SAFETY_TIMEOUT);
+}
+function createOverlayService() {
+  let styleInjected = false;
+  let dialog = null;
+  let modalResolve = null;
+  let modalOnClose;
+  let toastContainer = null;
+  let popoverEl = null;
+  let popoverAnchorObserver = null;
+  const supportsAnchor = typeof CSS !== "undefined" && CSS.supports("anchor-name", "--a");
+  function injectCSS() {
+    if (styleInjected)
+      return;
+    styleInjected = true;
+    const style = document.createElement("style");
+    style.textContent = overlayCSS;
+    document.head.appendChild(style);
+  }
+  function ensureDialog() {
+    if (dialog)
+      return dialog;
+    injectCSS();
+    dialog = document.createElement("dialog");
+    dialog.setAttribute("data-overlay-modal", "");
+    document.body.appendChild(dialog);
+    dialog.addEventListener("click", (e) => {
+      if (e.target === dialog) {
+        closeModal(void 0);
+      }
+    });
+    return dialog;
+  }
+  function ensureToastContainer() {
+    if (toastContainer)
+      return toastContainer;
+    injectCSS();
+    toastContainer = document.createElement("div");
+    toastContainer.setAttribute("data-overlay-toast-container", "");
+    document.body.appendChild(toastContainer);
+    return toastContainer;
+  }
+  function ensurePopover() {
+    if (popoverEl)
+      return popoverEl;
+    injectCSS();
+    popoverEl = document.createElement("div");
+    popoverEl.setAttribute("data-overlay-popover", "");
+    popoverEl.setAttribute("popover", "");
+    document.body.appendChild(popoverEl);
+    return popoverEl;
+  }
+  function modal(options) {
+    const d = ensureDialog();
+    d.removeAttribute("data-dismissing");
+    hidePopoverImmediate();
+    if (d.open) {
+      d.close();
+      if (modalResolve) {
+        modalResolve(void 0);
+        modalResolve = null;
+      }
+      if (modalOnClose) {
+        modalOnClose();
+        modalOnClose = void 0;
+      }
+    }
+    d.innerHTML = "";
+    options.render(d);
+    modalOnClose = options.onClose;
+    const { promise, resolve } = Promise.withResolvers();
+    modalResolve = resolve;
+    d.showModal();
+    return promise;
+  }
+  function closeModal(value) {
+    if (!dialog || !dialog.open)
+      return;
+    const resolve = modalResolve;
+    const onClose = modalOnClose;
+    const dialogRef = dialog;
+    modalResolve = null;
+    modalOnClose = void 0;
+    animateDismiss(dialogRef, () => {
+      if (dialogRef && dialogRef.open) {
+        dialogRef.close();
+        if (resolve)
+          resolve(value);
+        if (onClose)
+          onClose();
+      }
+    });
+  }
+  function clearDeadToasts(container) {
+    for (const child of [...container.children]) {
+      const el = child;
+      if (el.hasAttribute("data-dismissing")) {
+        el.remove();
+      }
+    }
+  }
+  function toast(options) {
+    const container = ensureToastContainer();
+    clearDeadToasts(container);
+    const el = document.createElement("div");
+    el.setAttribute("data-overlay-toast", "");
+    const timeout = options.timeout ?? 0;
+    if (timeout === 0) {
+      el.setAttribute("data-toast-manual", "");
+    } else {
+      el.style.setProperty("--overlay-toast-duration", `${timeout}ms`);
+    }
+    options.render(el);
+    container.appendChild(el);
+    let dismissed = false;
+    const dismiss = () => {
+      if (dismissed)
+        return;
+      dismissed = true;
+      el.setAttribute("data-dismissing", "");
+    };
+    return { dismiss };
+  }
+  function popover(options) {
+    const el = ensurePopover();
+    cleanupPopoverAnchorObserver();
+    try {
+      el.hidePopover();
+    } catch {
+    }
+    el.removeAttribute("data-dismissing");
+    el.innerHTML = "";
+    options.render(el);
+    if (supportsAnchor) {
+      const anchorName = "--overlay-anchor";
+      options.anchor.style.setProperty("anchor-name", anchorName);
+      el.style.setProperty("position-anchor", anchorName);
+      el.style.removeProperty("top");
+      el.style.removeProperty("left");
+    } else {
+      const rect = options.anchor.getBoundingClientRect();
+      el.style.top = `${rect.bottom + globalThis.scrollY}px`;
+      el.style.left = `${rect.left + globalThis.scrollX}px`;
+      el.style.position = "absolute";
+    }
+    el.showPopover();
+    watchAnchorDisconnect(options.anchor);
+  }
+  function watchAnchorDisconnect(anchor) {
+    cleanupPopoverAnchorObserver();
+    const parent = anchor.parentNode;
+    if (!parent) {
+      closePopover();
+      return;
+    }
+    popoverAnchorObserver = new MutationObserver(() => {
+      if (!document.contains(anchor)) {
+        closePopover();
+      }
+    });
+    popoverAnchorObserver.observe(parent, { childList: true });
+  }
+  function hidePopoverImmediate() {
+    cleanupPopoverAnchorObserver();
+    if (!popoverEl)
+      return;
+    try {
+      popoverEl.hidePopover();
+    } catch {
+    }
+    popoverEl.removeAttribute("data-dismissing");
+  }
+  function cleanupPopoverAnchorObserver() {
+    if (popoverAnchorObserver) {
+      popoverAnchorObserver.disconnect();
+      popoverAnchorObserver = null;
+    }
+  }
+  function closePopover() {
+    cleanupPopoverAnchorObserver();
+    if (!popoverEl)
+      return;
+    let isOpen;
+    try {
+      isOpen = popoverEl.matches(":popover-open");
+    } catch {
+      isOpen = popoverEl.hasAttribute("popover") && popoverEl.style.display !== "none";
+    }
+    if (!isOpen)
+      return;
+    animateDismiss(popoverEl, () => {
+      try {
+        popoverEl.hidePopover();
+      } catch {
+      }
+    });
+  }
+  function dismissAll() {
+    if (dialog && dialog.open) {
+      const resolve = modalResolve;
+      const onClose = modalOnClose;
+      modalResolve = null;
+      modalOnClose = void 0;
+      dialog.removeAttribute("data-dismissing");
+      dialog.close();
+      if (resolve)
+        resolve(void 0);
+      if (onClose)
+        onClose();
+    }
+    hidePopoverImmediate();
+    if (toastContainer) {
+      for (const child of toastContainer.children) {
+        child.setAttribute("data-dismissing", "");
+      }
+    }
+    try {
+      for (const el of document.querySelectorAll(":popover-open")) {
+        el.hidePopover();
+      }
+    } catch {
+    }
+    for (const el of document.querySelectorAll("dialog[open]")) {
+      if (el !== dialog)
+        el.close();
+    }
+  }
+  return {
+    modal,
+    closeModal,
+    toast,
+    popover,
+    closePopover,
+    dismissAll
+  };
+}
+
+// dist/src/widget/page-title.widget.js
+var PageTitleWidget = class extends WidgetComponent {
+  name = "page-title";
+  getData(args) {
+    return Promise.resolve({ title: args.params.title });
+  }
+  renderHTML(args) {
+    const title = args.data?.title ?? args.params.title;
+    if (title && typeof document !== "undefined") {
+      document.title = title;
+    }
+    return "";
+  }
+  renderMarkdown(_args) {
+    return "";
+  }
+  validateParams(params) {
+    if (!params.title || typeof params.title !== "string") {
+      return 'page-title widget requires a "title" string param';
+    }
+    return void 0;
+  }
+};
+
+// dist/src/widget/breadcrumb.widget.js
+var DEFAULT_HTML_SEPARATOR = " \u203A ";
+var DEFAULT_MD_SEPARATOR = " > ";
+var BreadcrumbWidget = class extends WidgetComponent {
+  name = "breadcrumb";
+  getData(args) {
+    const pathname = args.context.pathname || "/";
+    const parts = pathname.split("/").filter(Boolean);
+    const segments = [
+      { label: "Home", href: "/" }
+    ];
+    let accumulated = "";
+    for (const part of parts) {
+      accumulated += "/" + part;
+      segments.push({
+        label: part.charAt(0).toUpperCase() + part.slice(1).replace(/-/g, " "),
+        href: accumulated
+      });
+    }
+    return Promise.resolve({ segments });
+  }
+  renderHTML(args) {
+    if (!args.data || args.data.segments.length === 0)
+      return "";
+    const sep = args.params.separator ?? DEFAULT_HTML_SEPARATOR;
+    const segments = args.data.segments;
+    const items = segments.map((seg, i) => {
+      const escaped = escapeHtml(seg.label);
+      if (i === segments.length - 1) {
+        return `<span aria-current="page">${escaped}</span>`;
+      }
+      return `<a href="${escapeHtml(seg.href)}">${escaped}</a>`;
+    });
+    return `<nav aria-label="Breadcrumb">${items.join(escapeHtml(sep))}</nav>`;
+  }
+  renderMarkdown(args) {
+    if (!args.data || args.data.segments.length === 0)
+      return "";
+    const sep = args.params.separator ?? DEFAULT_MD_SEPARATOR;
+    return args.data.segments.map((seg, i, arr) => i === arr.length - 1 ? `**${seg.label}**` : `[${seg.label}](${seg.href})`).join(sep);
+  }
+};
+
+// dist/src/renderer/spa/mod.js
+if (globalThis.customElements) {
+  if (!customElements.get("router-slot"))
+    customElements.define("router-slot", RouterSlot);
+  if (!customElements.get("mark-down"))
+    customElements.define("mark-down", MarkdownElement);
+}
+
+// dist/src/util/widget-resolve.util.js
+var MAX_WIDGET_DEPTH = 10;
+async function resolveRecursively(content, parse, resolve, replace, depth = 0) {
+  if (depth >= MAX_WIDGET_DEPTH) {
+    logger.warn(`Widget nesting depth limit reached (${MAX_WIDGET_DEPTH}). Possible circular dependency or excessive nesting.`);
+    return content;
+  }
+  const widgets = parse(content);
+  if (widgets.length === 0)
+    return content;
+  const replacements = /* @__PURE__ */ new Map();
+  await Promise.all(widgets.map(async (widget) => {
+    let rendered = await resolve(widget);
+    rendered = await resolveRecursively(rendered, parse, resolve, replace, depth + 1);
+    replacements.set(widget, rendered);
+  }));
+  return replace(content, replacements);
+}
+function resolveWidgetTags(html, registry, routeInfo, loadFiles, contextProvider) {
+  const tagPattern = /<widget-(?<name>[a-z][a-z0-9-]*)(?<attrs>\s[^>]*)?>(?<content>.*?)<\/widget-\k<name>>/gis;
+  const wrappers = /* @__PURE__ */ new Map();
+  const ssrAttrPattern = new RegExp(`\\s${SSR_ATTR}(?:\\s|=|$)`);
+  const parse = (content) => {
+    const matches = content.matchAll(tagPattern).toArray();
+    return matches.filter((match) => {
+      const attrsString = match.groups.attrs || "";
+      return !ssrAttrPattern.test(attrsString);
+    });
+  };
+  const resolve = async (match) => {
+    const widgetName = match.groups.name;
+    const attrsString = match.groups.attrs?.trim() ?? "";
+    const widget = registry.get(widgetName);
+    if (!widget)
+      return match[0];
+    const params = parseAttrsToParams(attrsString);
+    try {
+      let files;
+      if (loadFiles) {
+        files = await loadFiles(widgetName, widget.files);
+      }
+      const baseContext = {
+        ...routeInfo,
+        pathname: routeInfo.url.pathname,
+        searchParams: routeInfo.url.searchParams,
+        files
+      };
+      const context = contextProvider ? contextProvider(baseContext) : baseContext;
+      const data = await widget.getData({ params, context });
+      const rendered = widget.renderHTML({ data, params, context });
+      wrappers.set(match, {
+        tagName: `widget-${widgetName}`,
+        attrs: attrsString ? ` ${attrsString}` : "",
+        ssrData: widget.exposeSsrData ? escapeAttr(JSON.stringify(data)) : ""
+      });
+      return rendered;
+    } catch (e) {
+      logger.error(`[SSR HTML] Widget "${widgetName}" render failed`, e instanceof Error ? e : void 0);
+      return match[0];
+    }
+  };
+  const replace = (content, replacements) => {
+    let result = content;
+    const entries = [...replacements.entries()].sort((a, b) => b[0].index - a[0].index);
+    for (const [match, innerHtml] of entries) {
+      const start = match.index;
+      const end = start + match[0].length;
+      const wrap = wrappers.get(match);
+      const lightDomData = wrap?.ssrData ? wrap.ssrData : "";
+      const replacement = wrap ? `<${wrap.tagName}${wrap.attrs} ${SSR_ATTR}><template shadowrootmode="open">${innerHtml}</template>${lightDomData}</${wrap.tagName}>` : innerHtml;
+      result = result.slice(0, start) + replacement + result.slice(end);
+    }
+    return result;
+  };
+  return resolveRecursively(html, parse, resolve, replace);
+}
+function parseAttrsToParams(attrsString) {
+  const params = {};
+  if (!attrsString)
+    return params;
+  const attrPattern = /(?<attr>[a-z][a-z0-9-]*)(?:="(?<dq>[^"]*)"|='(?<sq>[^']*)'|=(?<uq>[^\s>]+))?/gi;
+  for (const match of attrsString.matchAll(attrPattern)) {
+    const { attr: attrName, dq, sq, uq } = match.groups;
+    if (attrName === SSR_ATTR || attrName === LAZY_ATTR)
+      continue;
+    const key = attrName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const rawValue = dq ?? sq ?? uq;
+    if (rawValue === void 0) {
+      params[key] = "";
+      continue;
+    }
+    const raw = rawValue.replaceAll("&amp;", "&").replaceAll("&#39;", "'").replaceAll("&quot;", '"');
+    try {
+      params[key] = JSON.parse(raw);
+    } catch {
+      params[key] = raw;
+    }
+  }
+  return params;
+}
+function escapeAttr(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("'", "&#39;");
+}
+
+// dist/src/renderer/ssr/ssr.renderer.js
+var SsrRenderer = class _SsrRenderer {
+  core;
+  widgets;
+  widgetFiles;
+  constructor(resolver, options = {}) {
+    this.core = new RouteCore(resolver, options);
+    this.widgets = options.widgets ?? null;
+    this.widgetFiles = options.widgetFiles ?? {};
+  }
+  /**
+   * Render a URL to a content string.
+   */
+  async render(url, signal) {
+    const matched = this.core.match(url);
+    if (!matched) {
+      const statusPage = this.core.getStatusPage(404);
+      if (statusPage) {
+        try {
+          const ri = { url, params: {} };
+          const result = await this.renderRouteContent(ri, statusPage, void 0, signal);
+          return { content: this.stripSlots(result.content), status: 404, title: result.title };
+        } catch (e) {
+          logger.error(`[${this.label}] Failed to render 404 status page for ${url.pathname}`, e instanceof Error ? e : void 0);
+        }
+      }
+      return { content: this.renderStatusPage(404, url), status: 404 };
+    }
+    if (matched.route.type === "redirect") {
+      const module = await this.core.loadModule(matched.route.modulePath);
+      const redirectConfig = module.default;
+      assertSafeRedirect(redirectConfig.to);
+      return {
+        content: this.renderRedirect(redirectConfig.to),
+        status: redirectConfig.status ?? 301,
+        redirect: redirectConfig.to
+      };
+    }
+    const routeInfo = this.core.toRouteInfo(matched, url);
+    try {
+      const { content, title } = await this.renderPage(routeInfo, matched, signal);
+      return { content, status: 200, title };
+    } catch (error) {
+      if (error instanceof Response) {
+        const statusPage = this.core.getStatusPage(error.status);
+        if (statusPage) {
+          try {
+            const ri = { url, params: {} };
+            const result = await this.renderRouteContent(ri, statusPage, void 0, signal);
+            return {
+              content: this.stripSlots(result.content),
+              status: error.status,
+              title: result.title
+            };
+          } catch (e) {
+            logger.error(`[${this.label}] Failed to render ${error.status} status page for ${url.pathname}`, e instanceof Error ? e : void 0);
+          }
+        }
+        return { content: this.renderStatusPage(error.status, url), status: error.status };
+      }
+      logger.error(`[${this.label}] Error rendering ${url.pathname}:`, error instanceof Error ? error : void 0);
+      const boundary = this.core.findErrorBoundary(url.pathname);
+      if (boundary) {
+        const result = await this.tryRenderErrorModule(boundary.modulePath, url, "boundary");
+        if (result)
+          return result;
+      }
+      const errorHandler = this.core.getErrorHandler();
+      if (errorHandler) {
+        const result = await this.tryRenderErrorModule(errorHandler.modulePath, url, "handler");
+        if (result)
+          return result;
+      }
+      return { content: this.renderErrorPage(error, url), status: 500 };
+    }
+  }
+  /**
+   * Render a matched page by composing the route hierarchy.
+   */
+  async renderPage(routeInfo, matched, signal) {
+    const hierarchy = this.core.buildRouteHierarchy(matched.route.pattern);
+    const segments = [];
+    for (let i = 0; i < hierarchy.length; i++) {
+      const routePattern = hierarchy[i];
+      let route = this.core.findRoute(routePattern);
+      if (!route && routePattern === "/") {
+        route = DEFAULT_ROOT_ROUTE;
+      }
+      if (!route)
+        continue;
+      if (route === matched.route && routePattern !== matched.route.pattern)
+        continue;
+      segments.push({ route, isLeaf: i === hierarchy.length - 1 });
+    }
+    const results = await Promise.all(segments.map(({ route, isLeaf }) => this.renderRouteContent(routeInfo, route, isLeaf, signal)));
+    let result = "";
+    let pageTitle;
+    let lastRenderedPattern = "";
+    for (let i = 0; i < segments.length; i++) {
+      const { content, title } = results[i];
+      if (title) {
+        pageTitle = title;
+      }
+      if (result === "") {
+        result = content;
+      } else {
+        const injected = this.injectSlot(result, content, lastRenderedPattern);
+        if (injected === result) {
+          logger.warn(`[${this.label}] Route "${lastRenderedPattern}" has no <router-slot> for child route "${hierarchy[i]}" to render into. Add <router-slot></router-slot> to the parent template.`);
+        }
+        result = injected;
+      }
+      lastRenderedPattern = segments[i].route.pattern;
+    }
+    result = this.stripSlots(result);
+    return { content: result, title: pageTitle };
+  }
+  /** Load component, build context, get data, render content, get title. */
+  async loadRouteContent(routeInfo, route, isLeaf, signal) {
+    const files = route.files ?? {};
+    const tsModule = files.ts ?? files.js;
+    const component = tsModule ? (await this.core.loadModule(tsModule)).default : page_component_default;
+    const context = await this.core.buildComponentContext(routeInfo, route, signal, isLeaf);
+    const data = await component.getData({ params: routeInfo.params, signal, context });
+    const content = this.renderContent(component, { data, params: routeInfo.params, context });
+    const title = component.getTitle({ data, params: routeInfo.params, context });
+    return { content, title };
+  }
+  /** Render a component for error boundary/handler with minimal context. */
+  renderComponent(component, data, context) {
+    return this.renderContent(component, { data, params: {}, context });
+  }
+  static EMPTY_URL = new URL("http://error");
+  /** Try to load and render an error boundary or handler module. Returns null on failure. */
+  async tryRenderErrorModule(modulePath, url, kind) {
+    try {
+      const module = await this.core.loadModule(modulePath);
+      const component = module.default;
+      const minCtx = {
+        url: _SsrRenderer.EMPTY_URL,
+        params: {},
+        pathname: "",
+        searchParams: new URLSearchParams()
+      };
+      const data = await component.getData({ params: {}, context: minCtx });
+      const content = this.renderComponent(component, data, minCtx);
+      return { content, status: 500 };
+    } catch (e) {
+      logger.error(`[${this.label}] Error ${kind} failed for ${url.pathname}`, e instanceof Error ? e : void 0);
+      return null;
+    }
+  }
+};
+
+// dist/src/renderer/ssr/html.renderer.js
+var SsrHtmlRouter = class extends SsrRenderer {
+  label = "SSR HTML";
+  markdownRenderer;
+  markdownReady = null;
+  constructor(resolver, options = {}) {
+    super(resolver, options);
+    this.markdownRenderer = options.markdownRenderer ?? null;
+    if (this.markdownRenderer?.init) {
+      this.markdownReady = this.markdownRenderer.init();
+    }
+  }
+  injectSlot(parent, child, parentPattern) {
+    const escaped = parentPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return parent.replace(new RegExp(`<router-slot\\b[^>]*\\bpattern="${escaped}"[^>]*></router-slot>`), child);
+  }
+  stripSlots(result) {
+    return result.replace(/<router-slot[^>]*><\/router-slot>/g, "");
+  }
+  /**
+   * Render a single route's content.
+   */
+  async renderRouteContent(routeInfo, route, isLeaf, signal) {
+    if (route.modulePath === DEFAULT_ROOT_ROUTE.modulePath) {
+      return { content: `<router-slot pattern="${route.pattern}"></router-slot>` };
+    }
+    const { content: rawContent, title } = await this.loadRouteContent(routeInfo, route, isLeaf, signal);
+    let content = rawContent;
+    content = await this.expandMarkdown(content);
+    content = this.attributeSlots(content, route.pattern);
+    if (this.widgets) {
+      content = await resolveWidgetTags(content, this.widgets, routeInfo, (name, declared) => {
+        const files = this.widgetFiles[name] ?? declared;
+        return files ? this.core.loadWidgetFiles(files) : Promise.resolve({});
+      }, this.core.contextProvider);
+    }
+    return { content, title };
+  }
+  renderContent(component, args) {
+    return component.renderHTML(args);
+  }
+  renderRedirect(to) {
+    return `<meta http-equiv="refresh" content="0;url=${escapeHtml(to)}">`;
+  }
+  renderStatusPage(status, url) {
+    return `
+      <h1>${STATUS_MESSAGES[status] ?? "Error"}</h1>
+      <p>Path: ${escapeHtml(url.pathname)}</p>
+    `;
+  }
+  renderErrorPage(error, url) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `
+      <h1>Error</h1>
+      <p>Path: ${escapeHtml(url.pathname)}</p>
+      <p>${escapeHtml(message)}</p>
+    `;
+  }
+  /** Add pattern attribute to bare <router-slot> tags. */
+  attributeSlots(content, routePattern) {
+    return content.replace(/<router-slot(?![^>]*\bpattern=)([^>]*)><\/router-slot>/g, `<router-slot pattern="${routePattern}"$1></router-slot>`);
+  }
+  /**
+   * Expand <mark-down> tags by rendering markdown to HTML server-side.
+   * Leaves content unchanged if no markdown renderer is configured.
+   */
+  async expandMarkdown(content) {
+    if (!this.markdownRenderer)
+      return content;
+    if (!content.includes("<mark-down>"))
+      return content;
+    if (this.markdownReady) {
+      await this.markdownReady;
+    }
+    const renderer = this.markdownRenderer;
+    const pattern = /<mark-down>([\s\S]*?)<\/mark-down>/g;
+    return content.replace(pattern, (_match, escaped) => {
+      const markdown = unescapeHtml(escaped);
+      const rendered = renderer.render(markdown);
+      return rendered;
+    });
+  }
+};
+
+// dist/src/widget/widget.parser.js
+var WIDGET_PATTERN = /```widget:(?<name>[a-z][a-z0-9-]*)\n(?<params>.*?)```/gs;
+function parseWidgetBlocks(markdown) {
+  const blocks = [];
+  for (const match of markdown.matchAll(WIDGET_PATTERN)) {
+    const fullMatch = match[0];
+    const { name: widgetName, params: paramsRaw } = match.groups;
+    const paramsJson = paramsRaw.trim();
+    const startIndex = match.index;
+    const block = {
+      fullMatch,
+      widgetName,
+      params: null,
+      startIndex,
+      endIndex: startIndex + fullMatch.length
+    };
+    if (paramsJson) {
+      try {
+        const parsed = JSON.parse(paramsJson);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          block.params = parsed;
+        } else {
+          block.parseError = "Params must be a JSON object";
+        }
+      } catch (e) {
+        block.parseError = `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    } else {
+      block.params = {};
+    }
+    blocks.push(block);
+  }
+  return blocks;
+}
+function replaceWidgetBlocks(markdown, replacements) {
+  const sortedBlocks = [...replacements.entries()].sort(([a], [b]) => b.startIndex - a.startIndex);
+  let result = markdown;
+  for (const [block, replacement] of sortedBlocks) {
+    result = result.slice(0, block.startIndex) + replacement + result.slice(block.endIndex);
+  }
+  return result;
+}
+
+// dist/src/renderer/ssr/md.renderer.js
+var BARE_SLOT_BLOCK = "```router-slot\n```";
+function routerSlotBlock(pattern) {
+  return `\`\`\`router-slot
+{"pattern":"${pattern}"}
+\`\`\``;
+}
+var SsrMdRouter = class extends SsrRenderer {
+  label = "SSR MD";
+  constructor(resolver, options = {}) {
+    super(resolver, options);
+  }
+  injectSlot(parent, child, parentPattern) {
+    return parent.replace(routerSlotBlock(parentPattern), child);
+  }
+  stripSlots(result) {
+    return result.replace(/```router-slot\n(?:\{[^}]*\}\n)?```/g, "").trim();
+  }
+  /**
+   * Render a single route's content to Markdown.
+   */
+  async renderRouteContent(routeInfo, route, isLeaf, signal) {
+    if (route.modulePath === DEFAULT_ROOT_ROUTE.modulePath) {
+      return { content: routerSlotBlock(route.pattern) };
+    }
+    const { content: rawContent, title } = await this.loadRouteContent(routeInfo, route, isLeaf, signal);
+    let content = rawContent;
+    content = content.replaceAll(BARE_SLOT_BLOCK, routerSlotBlock(route.pattern));
+    if (this.widgets) {
+      content = await this.resolveWidgets(content, routeInfo);
+    }
+    return { content, title };
+  }
+  renderContent(component, args) {
+    return component.renderMarkdown(args);
+  }
+  renderRedirect(to) {
+    return `Redirect to: ${to}`;
+  }
+  renderStatusPage(status, url) {
+    return `# ${STATUS_MESSAGES[status] ?? "Error"}
+
+Path: \`${url.pathname}\``;
+  }
+  renderErrorPage(_error, url) {
+    return `# Internal Server Error
+
+Path: \`${url.pathname}\``;
+  }
+  /**
+   * Resolve fenced widget blocks in markdown content.
+   * Replaces ```widget:name blocks with rendered markdown output.
+   */
+  resolveWidgets(content, routeInfo) {
+    return resolveRecursively(content, parseWidgetBlocks, async (block) => {
+      if (block.parseError || !block.params) {
+        return `> **Error** (\`${block.widgetName}\`): ${block.parseError}`;
+      }
+      const widget = this.widgets.get(block.widgetName);
+      if (!widget) {
+        return `> **Error**: Unknown widget \`${block.widgetName}\``;
+      }
+      try {
+        let files;
+        const filePaths = this.widgetFiles[block.widgetName] ?? widget.files;
+        if (filePaths) {
+          files = await this.core.loadWidgetFiles(filePaths);
+        }
+        const baseContext = {
+          ...routeInfo,
+          pathname: routeInfo.url.pathname,
+          searchParams: routeInfo.url.searchParams,
+          files
+        };
+        const context = this.core.contextProvider ? this.core.contextProvider(baseContext) : baseContext;
+        const data = await widget.getData({ params: block.params, context });
+        return widget.renderMarkdown({ data, params: block.params, context });
+      } catch (e) {
+        return widget.renderMarkdownError(e);
+      }
+    }, replaceWidgetBlocks);
+  }
+};
+
+// dist/src/util/md.util.js
+function rewriteMdLinks(markdown, base, skipPrefixes) {
+  const prefix = base + "/";
+  const skip = skipPrefixes.map((p) => p.slice(1) + "/").join("|");
+  const inlineRe = new RegExp(`\\]\\(\\/(?!${skip})`, "g");
+  const refRe = new RegExp(`^(\\[[^\\]]+\\]:\\s+)\\/(?!${skip})`, "g");
+  const lines = markdown.split("\n");
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock)
+      continue;
+    lines[i] = lines[i].replaceAll(inlineRe, `](${prefix}`);
+    lines[i] = lines[i].replaceAll(refRe, `$1${prefix}`);
+  }
+  return lines.join("\n");
+}
+
+// dist/src/route/route-tree.util.js
+function resolveTargetNode(node, name, isRoot) {
+  if (name === "index") {
+    if (isRoot)
+      return node;
+    node.wildcard ??= { param: "rest", child: {} };
+    return node.wildcard.child;
+  }
+  if (name.startsWith("[") && name.endsWith("]")) {
+    const param = name.slice(1, -1);
+    node.dynamic ??= { param, child: {} };
+    return node.dynamic.child;
+  }
+  node.children ??= {};
+  node.children[name] ??= {};
+  return node.children[name];
+}
+
+// dist/runtime/abstract.runtime.js
+var DEFAULT_ROUTES_DIR = "/routes";
+var DEFAULT_WIDGETS_DIR = "/widgets";
+var ROUTES_MANIFEST_PATH = "/routes.manifest.json";
+var WIDGETS_MANIFEST_PATH = "/widgets.manifest.json";
+var Runtime = class {
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.config = config;
+  }
+  /** Write. Defaults to PUT; pass `{ method: "DELETE" }` etc. to override. */
+  command(resource, options) {
+    return this.handle(resource, { method: "PUT", ...options });
+  }
+  /**
+   * Dynamically import a module from this runtime's storage.
+   * Used by the server for SSR imports of `.page.ts` and `.widget.ts` files.
+   */
+  loadModule(_path) {
+    throw new Error(`loadModule not implemented for ${this.constructor.name}`);
+  }
+  // ── Manifest resolution ─────────────────────────────────────────────
+  routesManifestCache = null;
+  widgetsManifestCache = null;
+  /** Clear cached manifests so the next query triggers a fresh scan. */
+  invalidateManifests() {
+    this.routesManifestCache = null;
+    this.widgetsManifestCache = null;
+  }
+  /**
+   * Resolve the routes manifest. Called when the concrete runtime returns
+   * 404 for ROUTES_MANIFEST_PATH. Scans `config.routesDir` (or default).
+   */
+  async resolveRoutesManifest() {
+    if (this.routesManifestCache)
+      return this.routesManifestCache.clone();
+    const routesDir = this.config.routesDir ?? DEFAULT_ROUTES_DIR;
+    const dirResponse = await this.query(routesDir + "/");
+    if (dirResponse.status === 404) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const tree = await this.scanRoutes(routesDir);
+    this.routesManifestCache = Response.json(tree);
+    return this.routesManifestCache.clone();
+  }
+  /**
+   * Resolve the widgets manifest. Called when the concrete runtime returns
+   * 404 for WIDGETS_MANIFEST_PATH. Scans `config.widgetsDir` (or default).
+   */
+  async resolveWidgetsManifest() {
+    if (this.widgetsManifestCache)
+      return this.widgetsManifestCache.clone();
+    const widgetsDir = this.config.widgetsDir ?? DEFAULT_WIDGETS_DIR;
+    const dirResponse = await this.query(widgetsDir + "/");
+    if (dirResponse.status === 404) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const entries = await this.scanWidgets(widgetsDir, widgetsDir.replace(/^\//, ""));
+    this.widgetsManifestCache = Response.json(entries);
+    return this.widgetsManifestCache.clone();
+  }
+  // ── Scanning ──────────────────────────────────────────────────────────
+  async *walkDirectory(dir) {
+    const trailingDir = dir.endsWith("/") ? dir : dir + "/";
+    const response = await this.query(trailingDir);
+    const entries = await response.json();
+    for (const entry of entries) {
+      const path = `${trailingDir}${entry}`;
+      if (entry.endsWith("/")) {
+        yield* this.walkDirectory(path);
+      } else {
+        yield path;
+      }
+    }
+  }
+  /**
+   * Scan a routes directory and build a RouteNode tree.
+   * The filesystem structure maps directly to the tree — no intermediate array.
+   */
+  async scanRoutes(routesDir) {
+    const root = {};
+    const allFiles = [];
+    for await (const file of this.walkDirectory(routesDir)) {
+      allFiles.push(file);
+    }
+    for (const filePath of allFiles) {
+      const relativePath = filePath.replace(`${routesDir}/`, "");
+      const parts = relativePath.split("/");
+      const filename = parts[parts.length - 1];
+      const dirSegments = parts.slice(0, -1);
+      const match = filename.match(/^(.+?)\.(page|error|redirect)\.(ts|js|html|md|css)$/);
+      if (!match)
+        continue;
+      const [, name, kind, ext] = match;
+      let node = root;
+      for (const dir of dirSegments) {
+        if (dir.startsWith("[") && dir.endsWith("]")) {
+          const param = dir.slice(1, -1);
+          node.dynamic ??= { param, child: {} };
+          node = node.dynamic.child;
+        } else {
+          node.children ??= {};
+          node.children[dir] ??= {};
+          node = node.children[dir];
+        }
+      }
+      if (kind === "error") {
+        node.errorBoundary = filePath;
+        continue;
+      }
+      const target = resolveTargetNode(node, name, dirSegments.length === 0);
+      if (kind === "redirect") {
+        target.redirect = filePath;
+      } else {
+        target.files ??= {};
+        target.files[ext] = filePath;
+      }
+    }
+    return root;
+  }
+  async scanWidgets(widgetsDir, pathPrefix) {
+    const COMPANION_EXTENSIONS = ["html", "md", "css"];
+    const entries = [];
+    const trailingDir = widgetsDir.endsWith("/") ? widgetsDir : widgetsDir + "/";
+    const response = await this.query(trailingDir);
+    const listing = await response.json();
+    for (const item of listing) {
+      if (!item.endsWith("/"))
+        continue;
+      const name = item.slice(0, -1);
+      let moduleFile = `${name}.widget.ts`;
+      let modulePath = `${trailingDir}${name}/${moduleFile}`;
+      if ((await this.query(modulePath)).status === 404) {
+        moduleFile = `${name}.widget.js`;
+        modulePath = `${trailingDir}${name}/${moduleFile}`;
+        if ((await this.query(modulePath)).status === 404)
+          continue;
+      }
+      const prefix = pathPrefix ? `${pathPrefix}/` : "";
+      const entry = {
+        name,
+        modulePath: `${prefix}${name}/${moduleFile}`,
+        tagName: `widget-${name}`
+      };
+      const files = {};
+      let hasFiles = false;
+      for (const ext of COMPANION_EXTENSIONS) {
+        const companionFile = `${name}.widget.${ext}`;
+        const companionPath = `${trailingDir}${name}/${companionFile}`;
+        if ((await this.query(companionPath)).status !== 404) {
+          files[ext] = `${prefix}${name}/${companionFile}`;
+          hasFiles = true;
+        }
+      }
+      if (hasFiles)
+        entry.files = files;
+      entries.push(entry);
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    return entries;
+  }
+};
+
+// dist/server/emroute.server.js
+function createModuleLoaders(tree, runtime) {
+  const paths = /* @__PURE__ */ new Set();
+  function walk(node) {
+    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 = {};
+  for (const path of paths) {
+    loaders[path] = () => runtime.loadModule(path);
+  }
+  return loaders;
+}
+function extractWidgetExport(mod) {
+  for (const value of Object.values(mod)) {
+    if (!value)
+      continue;
+    if (typeof value === "object" && "getData" in value) {
+      return value;
+    }
+    if (typeof value === "function" && value.prototype?.getData) {
+      return new value();
+    }
+  }
+  return null;
+}
+async function importWidgets(entries, runtime, manual) {
+  const registry = new WidgetRegistry();
+  const widgetFiles = {};
+  for (const entry of entries) {
+    try {
+      const runtimePath = entry.modulePath.startsWith("/") ? entry.modulePath : `/${entry.modulePath}`;
+      const mod = await runtime.loadModule(runtimePath);
+      const instance = extractWidgetExport(mod);
+      if (!instance)
+        continue;
+      registry.add(instance);
+      const inlined = mod.__files;
+      if (inlined && typeof inlined === "object") {
+        widgetFiles[entry.name] = inlined;
+      } 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 };
+}
+function buildHtmlShell(title, htmlBase) {
+  const baseTag = htmlBase ? `
+  <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>`;
+}
+function injectSsrContent(html, content, title, ssrRoute) {
+  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;
+}
+async function resolveShell(runtime, title, htmlBase) {
+  const response = await runtime.query("/index.html");
+  if (response.status !== 404)
+    return await response.text();
+  return buildHtmlShell(title, htmlBase);
+}
+async function createEmrouteServer(config, runtime) {
+  const { spa = "root" } = config;
+  const { html: htmlBase, md: mdBase, app: appBase } = config.basePath ?? DEFAULT_BASE_PATH;
+  let routeTree;
+  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);
+  let widgets = config.widgets;
+  let widgetFiles = {};
+  let discoveredWidgetEntries = [];
+  const widgetsResponse = await runtime.query(WIDGETS_MANIFEST_PATH);
+  if (widgetsResponse.status !== 404) {
+    discoveredWidgetEntries = await widgetsResponse.json();
+    if (config.widgets) {
+      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;
+    }
+  }
+  let ssrHtmlRouter = null;
+  let ssrMdRouter = null;
+  function buildSsrRouters() {
+    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();
+  const title = config.title ?? "emroute";
+  let shell = await resolveShell(runtime, title, htmlBase);
+  if ((await runtime.query("/main.css")).status !== 404) {
+    shell = shell.replace("</head>", '  <link rel="stylesheet" href="/main.css">\n</head>');
+  }
+  async function handleRequest(req) {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const mdPrefix = mdBase + "/";
+    const htmlPrefix = htmlBase + "/";
+    const appPrefix = appBase + "/";
+    if (ssrMdRouter && (pathname.startsWith(mdPrefix) || pathname === mdBase)) {
+      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 });
+      }
+    }
+    if (ssrHtmlRouter && (pathname.startsWith(htmlPrefix) || pathname === htmlBase)) {
+      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 });
+      }
+    }
+    if (pathname.startsWith(appPrefix) || pathname === appBase) {
+      return new Response(shell, {
+        status: 200,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
+    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" }
+      });
+    }
+    const lastSegment = pathname.split("/").pop() ?? "";
+    if (lastSegment.includes(".")) {
+      const fileResponse = await runtime.handle(pathname);
+      if (fileResponse.status === 200)
+        return fileResponse;
+      return null;
+    }
+    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 {
+    handleRequest,
+    get htmlRouter() {
+      return ssrHtmlRouter;
+    },
+    get mdRouter() {
+      return ssrMdRouter;
+    },
+    get routeTree() {
+      return routeTree;
+    },
+    get widgetEntries() {
+      return discoveredWidgetEntries;
+    },
+    get shell() {
+      return shell;
+    }
+  };
+}
+
+// dist/runtime/fetch.runtime.js
+var __rewriteRelativeImportExtension2 = function(path, preserveJsx) {
+  if (typeof path === "string" && /^\.\.?\//.test(path)) {
+    return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+    });
+  }
+  return path;
+};
+var FetchRuntime = class extends Runtime {
+  origin;
+  /**
+   * @param origin — Server origin, e.g. `'http://localhost:4100'` or `location.origin`.
+   */
+  constructor(origin, config = {}) {
+    super(config);
+    this.origin = origin.endsWith("/") ? origin.slice(0, -1) : origin;
+  }
+  handle(resource, init) {
+    const url = this.toUrl(resource);
+    return fetch(url, init);
+  }
+  query(resource, options) {
+    if (options?.as === "text") {
+      return fetch(this.toUrl(resource)).then((r) => r.text());
+    }
+    return this.handle(resource, options);
+  }
+  async loadModule(path) {
+    const url = `${this.origin}${path}`;
+    const response = await fetch(url);
+    const js = await response.text();
+    const blob = new Blob([js], { type: "application/javascript" });
+    return import(__rewriteRelativeImportExtension2(URL.createObjectURL(blob)));
+  }
+  toUrl(resource) {
+    if (typeof resource === "string")
+      return `${this.origin}${resource}`;
+    if (resource instanceof URL)
+      return `${this.origin}${resource.pathname}${resource.search}`;
+    return `${this.origin}${new URL(resource.url).pathname}`;
+  }
+};
+export {
+  BreadcrumbWidget,
+  Component,
+  ComponentElement,
+  DEFAULT_BASE_PATH,
+  EmrouteApp,
+  FetchRuntime,
+  MarkdownElement,
+  PageComponent,
+  PageTitleWidget,
+  RouteTrie,
+  RouterSlot,
+  WidgetComponent,
+  WidgetRegistry,
+  createEmrouteApp,
+  createEmrouteServer,
+  createOverlayService,
+  escapeHtml,
+  scopeWidgetCss,
+  setLogger
+};
+//# sourceMappingURL=emroute.js.map