@vertz/ui-server 0.2.0 → 0.2.4

package/dist/bun-dev-server.js

@@ -0,0 +1,2247 @@
+// @bun
+import {
+  __require
+} from "./shared/chunk-eb80r8e8.js";
+
+// src/bun-dev-server.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, watch, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, normalize, resolve } from "path";
+
+// src/debug-logger.ts
+import { appendFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function createDebugLogger(logDir) {
+  const envValue = process.env.VERTZ_DEBUG;
+  if (!envValue) {
+    return {
+      log() {},
+      isEnabled() {
+        return false;
+      }
+    };
+  }
+  const enableAll = envValue === "1";
+  const enabledCategories = enableAll ? null : new Set(envValue.split(","));
+  const logFile = join(logDir, "debug.log");
+  writeFileSync(logFile, "");
+  function isEnabled(category) {
+    return enableAll || enabledCategories.has(category);
+  }
+  return {
+    log(category, message, data) {
+      if (!isEnabled(category))
+        return;
+      const entry = { cat: category, msg: message, ...data };
+      appendFileSync(logFile, JSON.stringify(entry) + `
+`);
+    },
+    isEnabled
+  };
+}
+
+// src/diagnostics-collector.ts
+class DiagnosticsCollector {
+  startTime = Date.now();
+  pluginFilter = "";
+  pluginHmr = false;
+  pluginFastRefresh = false;
+  processedFilesSet = new Set;
+  processedCount = 0;
+  ssrModuleStatus = "pending";
+  ssrLastReloadTime = null;
+  ssrLastReloadDurationMs = null;
+  ssrLastReloadError = null;
+  ssrReloadCount = 0;
+  ssrFailedReloadCount = 0;
+  hmrBundledScriptUrl = null;
+  hmrBootstrapDiscovered = false;
+  errorCurrent = null;
+  errorLastCategory = null;
+  errorLastMessage = null;
+  wsConnectedClients = 0;
+  watcherLastChangedFile = null;
+  watcherLastChangeTime = null;
+  recordPluginConfig(filter, hmr, fastRefresh) {
+    this.pluginFilter = filter;
+    this.pluginHmr = hmr;
+    this.pluginFastRefresh = fastRefresh;
+  }
+  recordPluginProcess(file) {
+    this.processedFilesSet.add(file);
+    this.processedCount++;
+  }
+  recordSSRReload(success, durationMs, error) {
+    this.ssrReloadCount++;
+    this.ssrLastReloadTime = new Date().toISOString();
+    this.ssrLastReloadDurationMs = durationMs;
+    if (success) {
+      this.ssrModuleStatus = "loaded";
+      this.ssrLastReloadError = null;
+    } else {
+      this.ssrModuleStatus = "error";
+      this.ssrLastReloadError = error ?? null;
+      this.ssrFailedReloadCount++;
+    }
+  }
+  recordHMRAssets(bundledScriptUrl, bootstrapDiscovered) {
+    this.hmrBundledScriptUrl = bundledScriptUrl;
+    this.hmrBootstrapDiscovered = bootstrapDiscovered;
+  }
+  recordError(category, message) {
+    this.errorCurrent = category;
+    this.errorLastCategory = category;
+    this.errorLastMessage = message;
+  }
+  recordErrorClear() {
+    this.errorCurrent = null;
+  }
+  recordWebSocketChange(count) {
+    this.wsConnectedClients = count;
+  }
+  recordFileChange(file) {
+    this.watcherLastChangedFile = file;
+    this.watcherLastChangeTime = new Date().toISOString();
+  }
+  getSnapshot() {
+    return {
+      status: "ok",
+      uptime: (Date.now() - this.startTime) / 1000,
+      plugin: {
+        filter: this.pluginFilter,
+        hmr: this.pluginHmr,
+        fastRefresh: this.pluginFastRefresh,
+        processedFiles: Array.from(this.processedFilesSet),
+        processedCount: this.processedCount
+      },
+      ssr: {
+        moduleStatus: this.ssrModuleStatus,
+        lastReloadTime: this.ssrLastReloadTime,
+        lastReloadDurationMs: this.ssrLastReloadDurationMs,
+        lastReloadError: this.ssrLastReloadError,
+        reloadCount: this.ssrReloadCount,
+        failedReloadCount: this.ssrFailedReloadCount
+      },
+      hmr: {
+        bundledScriptUrl: this.hmrBundledScriptUrl,
+        bootstrapDiscovered: this.hmrBootstrapDiscovered
+      },
+      errors: {
+        current: this.errorCurrent,
+        lastCategory: this.errorLastCategory,
+        lastMessage: this.errorLastMessage
+      },
+      websocket: {
+        connectedClients: this.wsConnectedClients
+      },
+      watcher: {
+        lastChangedFile: this.watcherLastChangedFile,
+        lastChangeTime: this.watcherLastChangeTime
+      }
+    };
+  }
+}
+
+// src/source-map-resolver.ts
+import { readFileSync } from "fs";
+import { resolve as resolvePath } from "path";
+import { originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
+function extractInlineSourceMap(jsContent) {
+  const match = jsContent.match(/\/\/# sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)/);
+  if (!match?.[1])
+    return null;
+  try {
+    return JSON.parse(atob(match[1]));
+  } catch {
+    return null;
+  }
+}
+function resolvePosition(sourceMapJSON, line, column) {
+  const tracer = new TraceMap(sourceMapJSON);
+  const pos = originalPositionFor(tracer, { line, column });
+  if (pos.source == null)
+    return null;
+  return {
+    source: pos.source,
+    line: pos.line ?? 1,
+    column: pos.column ?? 0,
+    name: pos.name
+  };
+}
+function readLineText(filePath, line) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    const idx = line - 1;
+    if (idx < 0 || idx >= lines.length)
+      return;
+    return lines[idx];
+  } catch {
+    return;
+  }
+}
+function parseStackFrames(stack) {
+  const frames = [];
+  const lines = stack.split(`
+`);
+  for (const line of lines) {
+    const namedMatch = line.match(/^\s+at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
+    if (namedMatch?.[1] && namedMatch[2]) {
+      frames.push({
+        functionName: namedMatch[1],
+        file: namedMatch[2],
+        line: Number(namedMatch[3]),
+        column: Number(namedMatch[4])
+      });
+      continue;
+    }
+    const anonMatch = line.match(/^\s+at\s+((?:https?:\/\/).+?):(\d+):(\d+)/);
+    if (anonMatch?.[1]) {
+      frames.push({
+        functionName: null,
+        file: anonMatch[1],
+        line: Number(anonMatch[2]),
+        column: Number(anonMatch[3])
+      });
+    }
+  }
+  return frames;
+}
+function createSourceMapResolver(projectRoot) {
+  const cache = new Map;
+  async function fetchAndCache(url, fetchFn) {
+    if (cache.has(url))
+      return cache.get(url) ?? null;
+    try {
+      const res = await fetchFn(url);
+      const jsContent = await res.text();
+      const sourceMap = extractInlineSourceMap(jsContent);
+      cache.set(url, sourceMap);
+      return sourceMap;
+    } catch {
+      cache.set(url, null);
+      return null;
+    }
+  }
+  return {
+    async resolve(bundledUrl, line, column, fetchFn) {
+      const sourceMap = await fetchAndCache(bundledUrl, fetchFn);
+      if (!sourceMap)
+        return null;
+      const pos = resolvePosition(sourceMap, line, column);
+      if (!pos)
+        return null;
+      return {
+        ...pos,
+        absSource: resolvePath(projectRoot, pos.source)
+      };
+    },
+    async resolveStack(stack, message, fetchFn) {
+      const frames = parseStackFrames(stack);
+      const resolvedFrames = [];
+      let topResolved = null;
+      for (const frame of frames) {
+        if (frame.file.includes("/_bun/")) {
+          const resolved = await this.resolve(frame.file, frame.line, frame.column, fetchFn);
+          if (resolved) {
+            if (!topResolved)
+              topResolved = resolved;
+            resolvedFrames.push({
+              functionName: frame.functionName,
+              file: resolved.source,
+              absFile: resolved.absSource,
+              line: resolved.line,
+              column: resolved.column
+            });
+            continue;
+          }
+        }
+        resolvedFrames.push({
+          functionName: frame.functionName,
+          file: frame.file,
+          absFile: frame.file,
+          line: frame.line,
+          column: frame.column
+        });
+      }
+      const errors = [];
+      if (topResolved) {
+        const lineText = readLineText(topResolved.absSource, topResolved.line);
+        errors.push({
+          message,
+          file: topResolved.source,
+          absFile: topResolved.absSource,
+          line: topResolved.line,
+          column: topResolved.column,
+          lineText
+        });
+      } else {
+        errors.push({ message });
+      }
+      return { errors, parsedStack: resolvedFrames };
+    },
+    invalidate() {
+      cache.clear();
+    }
+  };
+}
+
+// src/ssr-render.ts
+import { compileTheme } from "@vertz/ui";
+
+// src/dom-shim/index.ts
+import { setAdapter } from "@vertz/ui/internals";
+
+// src/dom-shim/ssr-node.ts
+class SSRNode {
+  childNodes = [];
+  parentNode = null;
+  get firstChild() {
+    return this.childNodes[0] ?? null;
+  }
+  get nextSibling() {
+    if (!this.parentNode)
+      return null;
+    const index = this.parentNode.childNodes.indexOf(this);
+    return this.parentNode.childNodes[index + 1] ?? null;
+  }
+  removeChild(child) {
+    const index = this.childNodes.indexOf(child);
+    if (index !== -1) {
+      this.childNodes.splice(index, 1);
+      child.parentNode = null;
+    }
+    return child;
+  }
+  insertBefore(newNode, referenceNode) {
+    if (!referenceNode) {
+      this.childNodes.push(newNode);
+      newNode.parentNode = this;
+    } else {
+      const index = this.childNodes.indexOf(referenceNode);
+      if (index !== -1) {
+        this.childNodes.splice(index, 0, newNode);
+        newNode.parentNode = this;
+      }
+    }
+    return newNode;
+  }
+  replaceChild(newNode, oldNode) {
+    const index = this.childNodes.indexOf(oldNode);
+    if (index !== -1) {
+      this.childNodes[index] = newNode;
+      newNode.parentNode = this;
+      oldNode.parentNode = null;
+    }
+    return oldNode;
+  }
+}
+
+// src/dom-shim/ssr-comment.ts
+class SSRComment extends SSRNode {
+  text;
+  constructor(text) {
+    super();
+    this.text = text;
+  }
+  get data() {
+    return this.text;
+  }
+  set data(value) {
+    this.text = value;
+  }
+}
+
+// src/types.ts
+function rawHtml(html) {
+  return { __raw: true, html };
+}
+
+// src/dom-shim/ssr-text-node.ts
+class SSRTextNode extends SSRNode {
+  text;
+  constructor(text) {
+    super();
+    this.text = text;
+  }
+  get data() {
+    return this.text;
+  }
+  set data(value) {
+    this.text = value;
+  }
+}
+
+// src/dom-shim/ssr-fragment.ts
+class SSRDocumentFragment extends SSRNode {
+  children = [];
+  appendChild(child) {
+    if (child instanceof SSRTextNode) {
+      this.children.push(child.text);
+      this.childNodes.push(child);
+      child.parentNode = this;
+    } else if (child instanceof SSRDocumentFragment) {
+      this.children.push(...child.children);
+      this.childNodes.push(...child.childNodes);
+      for (const fragmentChild of child.childNodes) {
+        fragmentChild.parentNode = this;
+      }
+    } else {
+      this.children.push(child);
+      this.childNodes.push(child);
+      child.parentNode = this;
+    }
+  }
+}
+
+// src/dom-shim/ssr-element.ts
+function createStyleProxy(element) {
+  const styles = {};
+  return new Proxy(styles, {
+    set(_target, prop, value) {
+      if (typeof prop === "string") {
+        styles[prop] = value;
+        const pairs = Object.entries(styles).map(([k, v]) => {
+          const key = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+          return `${key}: ${v}`;
+        });
+        element.attrs.style = pairs.join("; ");
+      }
+      return true;
+    },
+    get(_target, prop) {
+      if (typeof prop === "string") {
+        return styles[prop] ?? "";
+      }
+      return;
+    }
+  });
+}
+
+class SSRElement extends SSRNode {
+  tag;
+  attrs = {};
+  children = [];
+  _classList = new Set;
+  _textContent = null;
+  _innerHTML = null;
+  style;
+  constructor(tag) {
+    super();
+    this.tag = tag;
+    this.style = createStyleProxy(this);
+  }
+  setAttribute(name, value) {
+    if (name === "class") {
+      this._classList = new Set(value.split(/\s+/).filter(Boolean));
+    }
+    this.attrs[name] = value;
+  }
+  getAttribute(name) {
+    return this.attrs[name] ?? null;
+  }
+  removeAttribute(name) {
+    delete this.attrs[name];
+    if (name === "class") {
+      this._classList.clear();
+    }
+  }
+  appendChild(child) {
+    if (child instanceof SSRComment) {
+      this.children.push(child);
+      this.childNodes.push(child);
+      child.parentNode = this;
+    } else if (child instanceof SSRTextNode) {
+      this.children.push(child.text);
+      this.childNodes.push(child);
+      child.parentNode = this;
+    } else if (child instanceof SSRDocumentFragment) {
+      for (const fragmentChild of child.childNodes) {
+        if (fragmentChild instanceof SSRComment) {
+          this.children.push(fragmentChild);
+        } else if (fragmentChild instanceof SSRTextNode) {
+          this.children.push(fragmentChild.text);
+        } else if (fragmentChild instanceof SSRElement) {
+          this.children.push(fragmentChild);
+        }
+        this.childNodes.push(fragmentChild);
+        fragmentChild.parentNode = this;
+      }
+    } else {
+      this.children.push(child);
+      this.childNodes.push(child);
+      child.parentNode = this;
+    }
+  }
+  insertBefore(newNode, referenceNode) {
+    const refIdx = referenceNode ? this._findChildIndex(referenceNode) : -1;
+    const result = super.insertBefore(newNode, referenceNode);
+    if (newNode instanceof SSRDocumentFragment) {
+      const fragmentChildren = [];
+      for (const fc of newNode.childNodes) {
+        if (fc instanceof SSRComment)
+          fragmentChildren.push(fc);
+        else if (fc instanceof SSRTextNode)
+          fragmentChildren.push(fc.text);
+        else if (fc instanceof SSRElement)
+          fragmentChildren.push(fc);
+      }
+      if (!referenceNode || refIdx === -1) {
+        this.children.push(...fragmentChildren);
+      } else {
+        this.children.splice(refIdx, 0, ...fragmentChildren);
+      }
+    } else {
+      const child = newNode instanceof SSRComment ? newNode : newNode instanceof SSRTextNode ? newNode.text : newNode instanceof SSRElement ? newNode : null;
+      if (child != null) {
+        if (!referenceNode || refIdx === -1) {
+          this.children.push(child);
+        } else {
+          this.children.splice(refIdx, 0, child);
+        }
+      }
+    }
+    return result;
+  }
+  replaceChild(newNode, oldNode) {
+    const oldIdx = this._findChildIndex(oldNode);
+    const result = super.replaceChild(newNode, oldNode);
+    if (oldIdx !== -1) {
+      const newChild = newNode instanceof SSRComment ? newNode : newNode instanceof SSRTextNode ? newNode.text : newNode instanceof SSRElement ? newNode : null;
+      if (newChild != null) {
+        this.children[oldIdx] = newChild;
+      } else {
+        this.children.splice(oldIdx, 1);
+      }
+    }
+    return result;
+  }
+  _findChildIndex(node) {
+    return this.childNodes.indexOf(node);
+  }
+  removeChild(child) {
+    const idx = this._findChildIndex(child);
+    const result = super.removeChild(child);
+    if (idx !== -1) {
+      this.children.splice(idx, 1);
+    }
+    return result;
+  }
+  get classList() {
+    const self = this;
+    return {
+      add(cls) {
+        self._classList.add(cls);
+        self.attrs.class = [...self._classList].join(" ");
+      },
+      remove(cls) {
+        self._classList.delete(cls);
+        const val = [...self._classList].join(" ");
+        if (val) {
+          self.attrs.class = val;
+        } else {
+          delete self.attrs.class;
+        }
+      }
+    };
+  }
+  set className(value) {
+    this._classList = new Set(value.split(/\s+/).filter(Boolean));
+    if (value) {
+      this.attrs.class = value;
+    } else {
+      delete this.attrs.class;
+    }
+  }
+  get className() {
+    return this.attrs.class ?? "";
+  }
+  set textContent(value) {
+    this._textContent = value;
+    this.children = value ? [value] : [];
+    this.childNodes = [];
+  }
+  get textContent() {
+    return this._textContent;
+  }
+  set innerHTML(value) {
+    this._innerHTML = value;
+    this.children = value ? [value] : [];
+    this.childNodes = [];
+  }
+  get innerHTML() {
+    return this._innerHTML ?? "";
+  }
+  addEventListener(_event, _handler) {}
+  removeEventListener(_event, _handler) {}
+  toVNode() {
+    return {
+      tag: this.tag,
+      attrs: { ...this.attrs },
+      children: this.children.map((child) => {
+        if (typeof child === "string") {
+          return this._innerHTML != null ? rawHtml(child) : child;
+        }
+        if (child instanceof SSRComment)
+          return rawHtml(`<!--${child.text}-->`);
+        if (typeof child.toVNode === "function")
+          return child.toVNode();
+        return String(child);
+      })
+    };
+  }
+}
+
+// src/ssr-adapter.ts
+var BRAND = Symbol.for("vertz:render-node");
+Object.defineProperty(SSRNode.prototype, BRAND, {
+  value: true,
+  enumerable: false,
+  configurable: false,
+  writable: false
+});
+function createSSRAdapter() {
+  return {
+    createElement: (tag) => new SSRElement(tag),
+    createElementNS: (_ns, tag) => new SSRElement(tag),
+    createTextNode: (text) => new SSRTextNode(text),
+    createComment: (text) => new SSRComment(text),
+    createDocumentFragment: () => new SSRDocumentFragment,
+    isNode: (value) => value != null && typeof value === "object" && (BRAND in value)
+  };
+}
+
+// src/dom-shim/index.ts
+var SHIM_GLOBALS = [
+  "document",
+  "window",
+  "Node",
+  "HTMLElement",
+  "HTMLAnchorElement",
+  "HTMLDivElement",
+  "HTMLInputElement",
+  "HTMLButtonElement",
+  "HTMLSelectElement",
+  "HTMLTextAreaElement",
+  "DocumentFragment",
+  "MouseEvent",
+  "Event"
+];
+var savedGlobals = null;
+var shimInstalled = false;
+var installedGlobals = [];
+function installGlobal(name, value) {
+  if (globalThis[name] === undefined) {
+    Object.defineProperty(globalThis, name, {
+      value,
+      writable: true,
+      configurable: true
+    });
+    installedGlobals.push(name);
+  }
+}
+function installDomShim() {
+  for (const g of installedGlobals) {
+    delete globalThis[g];
+  }
+  installedGlobals = [];
+  setAdapter(createSSRAdapter());
+  const isSSRContext = typeof globalThis.__SSR_URL__ !== "undefined";
+  if (typeof document !== "undefined" && !isSSRContext && !shimInstalled) {
+    return;
+  }
+  if (!shimInstalled) {
+    savedGlobals = new Map;
+    for (const g of SHIM_GLOBALS) {
+      if (g in globalThis) {
+        savedGlobals.set(g, globalThis[g]);
+      }
+    }
+  }
+  shimInstalled = true;
+  const fakeDocument = {
+    createElement(tag) {
+      return new SSRElement(tag);
+    },
+    createTextNode(text) {
+      return new SSRTextNode(text);
+    },
+    createComment(text) {
+      return new SSRComment(text);
+    },
+    createDocumentFragment() {
+      return new SSRDocumentFragment;
+    },
+    head: new SSRElement("head"),
+    body: new SSRElement("body"),
+    querySelector: () => null,
+    querySelectorAll: () => [],
+    getElementById: () => null,
+    cookie: ""
+  };
+  globalThis.document = fakeDocument;
+  if (typeof window === "undefined") {
+    globalThis.window = {
+      location: { pathname: globalThis.__SSR_URL__ || "/", search: "", hash: "" },
+      addEventListener: () => {},
+      removeEventListener: () => {},
+      history: {
+        pushState: () => {},
+        replaceState: () => {}
+      }
+    };
+  } else {
+    globalThis.window.location = {
+      ...globalThis.window.location || {},
+      pathname: globalThis.__SSR_URL__ || "/"
+    };
+  }
+  globalThis.Node = SSRNode;
+  globalThis.HTMLElement = SSRElement;
+  globalThis.HTMLAnchorElement = SSRElement;
+  globalThis.HTMLDivElement = SSRElement;
+  globalThis.HTMLInputElement = SSRElement;
+  globalThis.HTMLButtonElement = SSRElement;
+  globalThis.HTMLSelectElement = SSRElement;
+  globalThis.HTMLTextAreaElement = SSRElement;
+  globalThis.DocumentFragment = SSRDocumentFragment;
+  globalThis.MouseEvent = class MockMouseEvent {
+  };
+  globalThis.Event = class MockEvent {
+  };
+  const storageStub = {
+    getItem: () => null,
+    setItem: () => {},
+    removeItem: () => {},
+    clear: () => {},
+    key: () => null,
+    length: 0
+  };
+  installGlobal("localStorage", storageStub);
+  installGlobal("sessionStorage", { ...storageStub });
+  installGlobal("navigator", {
+    userAgent: "",
+    language: "en",
+    languages: ["en"],
+    onLine: true,
+    cookieEnabled: false,
+    hardwareConcurrency: 1,
+    maxTouchPoints: 0,
+    platform: "",
+    vendor: ""
+  });
+  const NoopObserver = class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+      return [];
+    }
+  };
+  installGlobal("IntersectionObserver", NoopObserver);
+  installGlobal("ResizeObserver", NoopObserver);
+  installGlobal("MutationObserver", NoopObserver);
+  let nextFrameId = 1;
+  installGlobal("requestAnimationFrame", () => nextFrameId++);
+  installGlobal("cancelAnimationFrame", () => {});
+  installGlobal("requestIdleCallback", () => nextFrameId++);
+  installGlobal("cancelIdleCallback", () => {});
+  installGlobal("CustomEvent", class MockCustomEvent {
+    type;
+    detail;
+    constructor(type, init) {
+      this.type = type;
+      this.detail = init?.detail ?? null;
+    }
+  });
+}
+function removeDomShim() {
+  setAdapter(null);
+  if (!shimInstalled) {
+    return;
+  }
+  shimInstalled = false;
+  if (savedGlobals) {
+    for (const g of SHIM_GLOBALS) {
+      if (savedGlobals.has(g)) {
+        globalThis[g] = savedGlobals.get(g);
+      } else {
+        delete globalThis[g];
+      }
+    }
+    savedGlobals = null;
+  } else {
+    for (const g of SHIM_GLOBALS) {
+      delete globalThis[g];
+    }
+  }
+  for (const g of installedGlobals) {
+    delete globalThis[g];
+  }
+  installedGlobals = [];
+}
+function toVNode(element) {
+  if (element instanceof SSRElement) {
+    return element.toVNode();
+  }
+  if (element instanceof SSRDocumentFragment) {
+    return {
+      tag: "fragment",
+      attrs: {},
+      children: element.children.map((child) => {
+        if (typeof child === "string")
+          return child;
+        return child.toVNode();
+      })
+    };
+  }
+  if (typeof element === "object" && "tag" in element) {
+    return element;
+  }
+  return { tag: "span", attrs: {}, children: [String(element)] };
+}
+
+// src/html-serializer.ts
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_TEXT_ELEMENTS = new Set(["script", "style"]);
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(value) {
+  const str = typeof value === "string" ? value : String(value);
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function serializeAttrs(attrs) {
+  const parts = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    parts.push(` ${key}="${escapeAttr(value)}"`);
+  }
+  return parts.join("");
+}
+function isRawHtml(value) {
+  return typeof value === "object" && "__raw" in value && value.__raw === true;
+}
+function serializeToHtml(node) {
+  if (typeof node === "string") {
+    return escapeHtml(node);
+  }
+  if (isRawHtml(node)) {
+    return node.html;
+  }
+  const { tag, attrs, children } = node;
+  const attrStr = serializeAttrs(attrs);
+  if (VOID_ELEMENTS.has(tag)) {
+    return `<${tag}${attrStr}>`;
+  }
+  const isRawText = RAW_TEXT_ELEMENTS.has(tag);
+  const childrenHtml = children.map((child) => {
+    if (typeof child === "string" && isRawText) {
+      return child;
+    }
+    return serializeToHtml(child);
+  }).join("");
+  return `<${tag}${attrStr}>${childrenHtml}</${tag}>`;
+}
+
+// src/slot-placeholder.ts
+var slotCounter = 0;
+function createSlotPlaceholder(fallback) {
+  const id = slotCounter++;
+  const placeholder = {
+    tag: "div",
+    attrs: { id: `v-slot-${id}` },
+    children: typeof fallback === "string" ? [fallback] : [fallback],
+    _slotId: id
+  };
+  return placeholder;
+}
+
+// src/streaming.ts
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+function encodeChunk(html) {
+  return encoder.encode(html);
+}
+async function streamToString(stream) {
+  const reader = stream.getReader();
+  const parts = [];
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    parts.push(decoder.decode(value, { stream: true }));
+  }
+  parts.push(decoder.decode());
+  return parts.join("");
+}
+
+// src/template-chunk.ts
+function createTemplateChunk(slotId, resolvedHtml, nonce) {
+  const tmplId = `v-tmpl-${slotId}`;
+  const slotRef = `v-slot-${slotId}`;
+  const nonceAttr = nonce != null ? ` nonce="${escapeAttr(nonce)}"` : "";
+  return `<template id="${tmplId}">${resolvedHtml}</template>` + `<script${nonceAttr}>` + `(function(){` + `var s=document.getElementById("${slotRef}");` + `var t=document.getElementById("${tmplId}");` + `if(s&&t){s.replaceWith(t.content.cloneNode(true));t.remove()}` + `})()` + "</script>";
+}
+
+// src/render-to-stream.ts
+function isSuspenseNode(node) {
+  return typeof node === "object" && "tag" in node && node.tag === "__suspense" && "_resolve" in node;
+}
+function renderToStream(tree, options) {
+  const pendingBoundaries = [];
+  function walkAndSerialize(node) {
+    if (typeof node === "string") {
+      return escapeHtml(node);
+    }
+    if (isRawHtml(node)) {
+      return node.html;
+    }
+    if (isSuspenseNode(node)) {
+      const placeholder = createSlotPlaceholder(node._fallback);
+      pendingBoundaries.push({
+        slotId: placeholder._slotId,
+        resolve: node._resolve
+      });
+      return serializeToHtml(placeholder);
+    }
+    const { tag, attrs, children } = node;
+    const isRawText = RAW_TEXT_ELEMENTS.has(tag);
+    const attrStr = Object.entries(attrs).map(([k, v]) => ` ${k}="${escapeAttr(v)}"`).join("");
+    if (VOID_ELEMENTS.has(tag)) {
+      return `<${tag}${attrStr}>`;
+    }
+    const childrenHtml = children.map((child) => {
+      if (typeof child === "string" && isRawText) {
+        return child;
+      }
+      return walkAndSerialize(child);
+    }).join("");
+    return `<${tag}${attrStr}>${childrenHtml}</${tag}>`;
+  }
+  return new ReadableStream({
+    async start(controller) {
+      const mainHtml = walkAndSerialize(tree);
+      controller.enqueue(encodeChunk(mainHtml));
+      if (pendingBoundaries.length > 0) {
+        const nonce = options?.nonce;
+        const resolutions = pendingBoundaries.map(async (boundary) => {
+          try {
+            const resolved = await boundary.resolve;
+            const resolvedHtml = serializeToHtml(resolved);
+            return createTemplateChunk(boundary.slotId, resolvedHtml, nonce);
+          } catch (_err) {
+            const errorHtml = `<div data-v-ssr-error="true" id="v-ssr-error-${boundary.slotId}">` + "<!--SSR error--></div>";
+            return createTemplateChunk(boundary.slotId, errorHtml, nonce);
+          }
+        });
+        const chunks = await Promise.all(resolutions);
+        for (const chunk of chunks) {
+          controller.enqueue(encodeChunk(chunk));
+        }
+      }
+      controller.close();
+    }
+  });
+}
+
+// src/ssr-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var ssrStorage = new AsyncLocalStorage;
+function isInSSR() {
+  return ssrStorage.getStore() !== undefined;
+}
+function registerSSRQuery(entry) {
+  ssrStorage.getStore()?.queries.push(entry);
+}
+function getSSRQueries() {
+  return ssrStorage.getStore()?.queries ?? [];
+}
+function setGlobalSSRTimeout(timeout) {
+  const store = ssrStorage.getStore();
+  if (store)
+    store.globalSSRTimeout = timeout;
+}
+function clearGlobalSSRTimeout() {
+  const store = ssrStorage.getStore();
+  if (store)
+    store.globalSSRTimeout = undefined;
+}
+function getGlobalSSRTimeout() {
+  return ssrStorage.getStore()?.globalSSRTimeout;
+}
+globalThis.__VERTZ_IS_SSR__ = isInSSR;
+globalThis.__VERTZ_SSR_REGISTER_QUERY__ = registerSSRQuery;
+globalThis.__VERTZ_GET_GLOBAL_SSR_TIMEOUT__ = getGlobalSSRTimeout;
+
+// src/ssr-streaming-runtime.ts
+function safeSerialize(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c");
+}
+
+// src/ssr-render.ts
+var renderLock = Promise.resolve();
+function withRenderLock(fn) {
+  const prev = renderLock;
+  let release;
+  renderLock = new Promise((r) => {
+    release = r;
+  });
+  return prev.then(fn).finally(() => release());
+}
+function resolveAppFactory(module) {
+  const createApp = module.default || module.App;
+  if (typeof createApp !== "function") {
+    throw new Error("App entry must export a default function or named App function");
+  }
+  return createApp;
+}
+function collectCSS(themeCss, module) {
+  const themeTag = themeCss ? `<style data-vertz-css>${themeCss}</style>` : "";
+  const globalTags = module.styles ? module.styles.map((s) => `<style data-vertz-css>${s}</style>`).join(`
+`) : "";
+  const alreadyIncluded = new Set;
+  if (themeCss)
+    alreadyIncluded.add(themeCss);
+  if (module.styles) {
+    for (const s of module.styles)
+      alreadyIncluded.add(s);
+  }
+  let componentCss;
+  if (module.getInjectedCSS) {
+    componentCss = module.getInjectedCSS().filter((s) => !alreadyIncluded.has(s));
+  } else {
+    componentCss = [];
+    const head = globalThis.document?.head;
+    if (head instanceof SSRElement) {
+      for (const child of head.children) {
+        if (child instanceof SSRElement && child.tag === "style" && "data-vertz-css" in child.attrs && child.textContent && !alreadyIncluded.has(child.textContent)) {
+          componentCss.push(child.textContent);
+        }
+      }
+    }
+  }
+  const componentStyles = componentCss.map((s) => `<style data-vertz-css>${s}</style>`).join(`
+`);
+  return [themeTag, globalTags, componentStyles].filter(Boolean).join(`
+`);
+}
+async function ssrRenderToString(module, url, options) {
+  return withRenderLock(() => ssrRenderToStringUnsafe(module, url, options));
+}
+async function ssrRenderToStringUnsafe(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  return ssrStorage.run({ url: normalizedUrl, errors: [], queries: [] }, async () => {
+    globalThis.__SSR_URL__ = normalizedUrl;
+    installDomShim();
+    globalThis.__VERTZ_CLEAR_QUERY_CACHE__?.();
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      let themeCss = "";
+      if (module.theme) {
+        try {
+          themeCss = compileTheme(module.theme).css;
+        } catch (e) {
+          console.error("[vertz] Failed to compile theme export. Ensure your theme is created with defineTheme().", e);
+        }
+      }
+      globalThis.__VERTZ_SSR_SYNC_ROUTER__?.(normalizedUrl);
+      createApp();
+      const queries = getSSRQueries();
+      const resolvedQueries = [];
+      if (queries.length > 0) {
+        await Promise.allSettled(queries.map(({ promise, timeout, resolve, key }) => Promise.race([
+          promise.then((data) => {
+            resolve(data);
+            resolvedQueries.push({ key, data });
+            return "resolved";
+          }),
+          new Promise((r) => setTimeout(r, timeout || ssrTimeout)).then(() => "timeout")
+        ])));
+        const store = ssrStorage.getStore();
+        if (store)
+          store.queries = [];
+      }
+      const app = createApp();
+      const vnode = toVNode(app);
+      const stream = renderToStream(vnode);
+      const html = await streamToString(stream);
+      const css = collectCSS(themeCss, module);
+      const ssrData = resolvedQueries.length > 0 ? resolvedQueries.map(({ key, data }) => ({
+        key,
+        data: JSON.parse(JSON.stringify(data))
+      })) : [];
+      return { html, css, ssrData };
+    } finally {
+      clearGlobalSSRTimeout();
+      removeDomShim();
+      delete globalThis.__SSR_URL__;
+    }
+  });
+}
+async function ssrStreamNavQueries(module, url, options) {
+  const normalizedUrl = url.endsWith("/index.html") ? url.slice(0, -"/index.html".length) || "/" : url;
+  const ssrTimeout = options?.ssrTimeout ?? 300;
+  const navTimeout = options?.navSsrTimeout ?? 5000;
+  const queries = await withRenderLock(() => ssrStorage.run({ url: normalizedUrl, errors: [], queries: [] }, async () => {
+    globalThis.__SSR_URL__ = normalizedUrl;
+    installDomShim();
+    globalThis.__VERTZ_CLEAR_QUERY_CACHE__?.();
+    try {
+      setGlobalSSRTimeout(ssrTimeout);
+      const createApp = resolveAppFactory(module);
+      globalThis.__VERTZ_SSR_SYNC_ROUTER__?.(normalizedUrl);
+      createApp();
+      const discovered = getSSRQueries();
+      return discovered.map((q) => ({
+        promise: q.promise,
+        timeout: q.timeout || ssrTimeout,
+        resolve: q.resolve,
+        key: q.key
+      }));
+    } finally {
+      clearGlobalSSRTimeout();
+      removeDomShim();
+      delete globalThis.__SSR_URL__;
+    }
+  }));
+  if (queries.length === 0) {
+    const encoder3 = new TextEncoder;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder3.encode(`event: done
+data: {}
+
+`));
+        controller.close();
+      }
+    });
+  }
+  const encoder2 = new TextEncoder;
+  let remaining = queries.length;
+  return new ReadableStream({
+    start(controller) {
+      let closed = false;
+      function safeEnqueue(chunk) {
+        if (closed)
+          return;
+        try {
+          controller.enqueue(chunk);
+        } catch {
+          closed = true;
+        }
+      }
+      function safeClose() {
+        if (closed)
+          return;
+        closed = true;
+        try {
+          controller.close();
+        } catch {}
+      }
+      function checkDone() {
+        if (remaining === 0) {
+          safeEnqueue(encoder2.encode(`event: done
+data: {}
+
+`));
+          safeClose();
+        }
+      }
+      for (const { promise, resolve, key } of queries) {
+        let settled = false;
+        promise.then((data) => {
+          if (settled)
+            return;
+          settled = true;
+          resolve(data);
+          const entry = { key, data: JSON.parse(JSON.stringify(data)) };
+          safeEnqueue(encoder2.encode(`event: data
+data: ${safeSerialize(entry)}
+
+`));
+          remaining--;
+          checkDone();
+        }, () => {
+          if (settled)
+            return;
+          settled = true;
+          remaining--;
+          checkDone();
+        });
+        setTimeout(() => {
+          if (settled)
+            return;
+          settled = true;
+          remaining--;
+          checkDone();
+        }, navTimeout);
+      }
+    }
+  });
+}
+
+// src/bun-dev-server.ts
+function killStaleProcess(targetPort) {
+  try {
+    const output = execSync(`lsof -ti :${targetPort}`, { encoding: "utf8" }).trim();
+    if (!output)
+      return;
+    const pids = output.split(`
+`).filter(Boolean);
+    const myPid = String(process.pid);
+    for (const pid of pids) {
+      if (pid === myPid)
+        continue;
+      try {
+        process.kill(Number(pid), "SIGTERM");
+        console.log(`[Server] Killed stale process on port ${targetPort} (PID ${pid})`);
+      } catch {}
+    }
+  } catch {}
+}
+function createIndexHtmlStasher(projectRoot) {
+  const indexHtmlPath = resolve(projectRoot, "index.html");
+  const indexHtmlBackupPath = resolve(projectRoot, ".vertz", "dev", "index.html.bak");
+  let stashed = false;
+  return {
+    stash() {
+      if (!existsSync(indexHtmlPath) && existsSync(indexHtmlBackupPath)) {
+        renameSync(indexHtmlBackupPath, indexHtmlPath);
+      }
+      if (existsSync(indexHtmlPath)) {
+        mkdirSync(resolve(projectRoot, ".vertz", "dev"), { recursive: true });
+        renameSync(indexHtmlPath, indexHtmlBackupPath);
+        stashed = true;
+      }
+    },
+    restore() {
+      if (stashed && existsSync(indexHtmlBackupPath)) {
+        renameSync(indexHtmlBackupPath, indexHtmlPath);
+        stashed = false;
+      }
+    }
+  };
+}
+function parseHMRAssets(html) {
+  const srcMatch = html.match(/src="(\/_bun\/client\/[^"]+\.js)"/);
+  const bootstrapMatch = html.match(/<script>(\(\(a\)=>\{document\.addEventListener.*?)<\/script>/);
+  return {
+    scriptUrl: srcMatch?.[1] ?? null,
+    bootstrapScript: bootstrapMatch?.[1] ? `<script>${bootstrapMatch[1]}</script>` : null
+  };
+}
+function detectEditor(explicit) {
+  if (explicit)
+    return explicit;
+  const env = process.env.VERTZ_EDITOR || process.env.EDITOR || "";
+  const lower = env.toLowerCase();
+  if (lower.includes("cursor"))
+    return "cursor";
+  if (lower.includes("zed"))
+    return "zed";
+  if (lower.includes("webstorm") || lower.includes("idea"))
+    return "webstorm";
+  return "vscode";
+}
+function editorHrefJs(editor) {
+  if (editor === "webstorm" || editor === "idea") {
+    return `V._editorHref=function(f,l){if(!f)return'';return'${editor}://open?file='+encodeURI(f)+(l?'&line='+l:'')};`;
+  }
+  return `V._editorHref=function(f,l){if(!f)return'';return'${editor}://file/'+encodeURI(f)+(l?':'+l:'')};`;
+}
+function buildErrorChannelScript(editor) {
+  return [
+    "<style>bun-hmr{display:none!important}</style>",
+    "<script>(function(){",
+    "var V=window.__vertz_overlay={};",
+    editorHrefJs(editor),
+    "V._ws=null;",
+    "V._src=null;",
+    "V._hadClientError=false;",
+    "V._needsReload=false;",
+    'var rts=sessionStorage.getItem("__vertz_recovering");',
+    "V._recovering=rts&&(Date.now()-Number(rts)<10000);",
+    'if(V._recovering)sessionStorage.removeItem("__vertz_recovering");',
+    "var _reload=location.reload.bind(location);",
+    "try{location.reload=function(){if(V._src){V._needsReload=true;return}_reload()}}catch(e){}",
+    "V.esc=function(s){return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')};",
+    "V.formatErrors=function(errs){",
+    `if(!errs||!errs.length)return'<p style="margin:0;color:var(--ve-muted);font-size:12px">Check your terminal for details.</p>';`,
+    "var groups=[],seen={};",
+    "errs.forEach(function(e){",
+    "var k=(e.file||'')+'|'+(e.line||0);",
+    "if(!seen[k]){seen[k]={file:e.file,absFile:e.absFile,line:e.line,lineText:e.lineText,msgs:[]};groups.push(seen[k])}",
+    "seen[k].msgs.push({message:e.message,column:e.column})});",
+    "return groups.map(function(g){var h='';",
+    "if(g.file){",
+    "var loc=V.esc(g.file)+(g.line?':'+g.line:'');",
+    "var href=V._editorHref(g.absFile,g.line);",
+    `h+=href?'<a href="'+href+'" style="color:var(--ve-link);font-size:12px;text-decoration:underline;text-underline-offset:2px">'+loc+'</a>'` + `:'<span style="color:var(--ve-link);font-size:12px">'+loc+'</span>';`,
+    "h+='<br>'}",
+    `g.msgs.forEach(function(m){h+='<div style="color:var(--ve-error);font-size:12px;margin:2px 0">'+V.esc(m.message)+'</div>'});`,
+    `if(g.lineText){h+='<pre style="margin:4px 0 0;color:var(--ve-code);font-size:11px;background:var(--ve-code-bg);border-radius:4px;padding:6px 8px;overflow-x:auto;border:1px solid var(--ve-border)">'+V.esc(g.lineText)+'</pre>'}`,
+    `return'<div style="margin-bottom:10px">'+h+'</div>'}).join('')};`,
+    "V.formatStack=function(frames){",
+    "if(!frames||!frames.length)return'';",
+    `var h='<div style="margin-top:8px;border-top:1px solid var(--ve-border);padding-top:8px">';`,
+    "var visible=frames.slice(0,3);var hidden=frames.slice(3);",
+    "visible.forEach(function(f){h+=V._renderFrame(f)});",
+    `if(hidden.length){h+='<details style="margin-top:2px"><summary style="color:var(--ve-muted);font-size:11px;cursor:pointer;list-style:none">'`,
+    "+hidden.length+' more frame'+(hidden.length>1?'s':'')+'</summary>';",
+    "hidden.forEach(function(f){h+=V._renderFrame(f)});h+='</details>'}",
+    "return h+'</div>'};",
+    "V._renderFrame=function(f){",
+    "var name=f.functionName||'(anonymous)';",
+    "var loc=V.esc(f.file)+(f.line?':'+f.line:'');",
+    "var isSrc=f.file&&f.file.indexOf('src/')!==-1&&f.file.indexOf('node_modules')===-1;",
+    "var color=isSrc?'var(--ve-fg)':'var(--ve-muted)';",
+    "var href=V._editorHref(f.absFile,f.line);",
+    `var link=href?'<a href="'+href+'" style="color:var(--ve-link);text-decoration:underline;text-underline-offset:2px">'+loc+'</a>':'<span>'+loc+'</span>';`,
+    `return'<div style="font-size:11px;color:'+color+';margin:1px 0;font-family:ui-monospace,monospace">'+V.esc(name)+' '+link+'</div>'};`,
+    "V.removeOverlay=function(){V._src=null;var e=document.getElementById('__vertz_error');if(e)e.remove();" + "var d=document.getElementById('__vertz_error_data');if(d)d.remove()};",
+    "V.showOverlay=function(t,body,payload,src){",
+    "V.removeOverlay();",
+    "V._src=src||'ws';",
+    "var d=document,c=d.createElement('div');",
+    "c.id='__vertz_error';",
+    "c.style.cssText='",
+    "--ve-bg:hsl(0 0% 100%);--ve-fg:hsl(0 0% 9%);--ve-muted:hsl(0 0% 45%);",
+    "--ve-error:hsl(0 72% 51%);--ve-link:hsl(221 83% 53%);--ve-border:hsl(0 0% 90%);",
+    "--ve-code:hsl(24 70% 45%);--ve-code-bg:hsl(0 0% 97%);--ve-btn:hsl(0 0% 9%);--ve-btn-fg:hsl(0 0% 100%);",
+    "position:fixed;bottom:16px;left:50%;transform:translateX(-50%);z-index:2147483647;",
+    "background:var(--ve-bg);color:var(--ve-fg);border-radius:8px;padding:14px 16px;",
+    "max-width:480px;width:calc(100% - 32px);font-family:ui-sans-serif,system-ui,sans-serif;",
+    "box-shadow:0 4px 24px rgba(0,0,0,0.12),0 1px 3px rgba(0,0,0,0.08);border:1px solid var(--ve-border)';",
+    "var st=d.createElement('style');",
+    "st.textContent='@media(prefers-color-scheme:dark){#__vertz_error{",
+    "--ve-bg:hsl(0 0% 7%);--ve-fg:hsl(0 0% 93%);--ve-muted:hsl(0 0% 55%);",
+    "--ve-error:hsl(0 72% 65%);--ve-link:hsl(217 91% 70%);--ve-border:hsl(0 0% 18%);",
+    "--ve-code:hsl(36 80% 65%);--ve-code-bg:hsl(0 0% 11%);--ve-btn:hsl(0 0% 93%);--ve-btn-fg:hsl(0 0% 7%)}}';",
+    "d.head.appendChild(st);",
+    `c.innerHTML='<div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:10px">'`,
+    `+'<span style="font-size:13px;font-weight:600;color:var(--ve-error)">'+V.esc(t)+'</span>'`,
+    `+'<button id="__vertz_retry" style="background:var(--ve-btn);color:var(--ve-btn-fg);border:none;border-radius:6px;padding:4px 12px;font-size:12px;cursor:pointer;font-weight:500">Retry</button>'`,
+    "+'</div>'+body;",
+    "(d.body||d.documentElement).appendChild(c);",
+    "d.getElementById('__vertz_retry').onclick=function(){location.reload()};",
+    "if(payload){var s=d.createElement('script');s.type='application/json';s.id='__vertz_error_data';s.textContent=JSON.stringify(payload);(d.body||d.documentElement).appendChild(s)}};",
+    "var delay=1000,maxDelay=30000;",
+    "function connect(){",
+    "var p=location.protocol==='https:'?'wss:':'ws:';",
+    "var ws=new WebSocket(p+'//'+location.host+'/__vertz_errors');",
+    "V._ws=ws;",
+    "ws.onmessage=function(e){",
+    "try{var m=JSON.parse(e.data);",
+    "if(m.type==='error'){",
+    "if(V._recovering)return;",
+    "V.showOverlay(m.category==='build'?'Build failed':m.category==='ssr'?'SSR error':m.category==='resolve'?'Module not found':'Runtime error',V.formatErrors(m.errors)+V.formatStack(m.parsedStack),m,'ws')}",
+    "else if(m.type==='clear'){",
+    "if(V._needsReload){V._needsReload=false;V.removeOverlay();sessionStorage.setItem('__vertz_recovering',String(Date.now()));_reload();return}",
+    "var a=document.getElementById('app');",
+    "if(!a||a.innerHTML.length<50){V.removeOverlay();sessionStorage.setItem('__vertz_recovering',String(Date.now()));_reload();return}",
+    "if(V._hadClientError)return;",
+    "V.removeOverlay()}",
+    "else if(m.type==='connected'){delay=1000}",
+    "}catch(ex){}};",
+    "ws.onclose=function(){V._ws=null;setTimeout(function(){delay=Math.min(delay*2,maxDelay);connect()},delay)};",
+    "ws.onerror=function(){ws.close()}}",
+    "connect();",
+    "V._sendResolveStack=function(stack,msg){",
+    'if(V._ws&&V._ws.readyState===1){try{V._ws.send(JSON.stringify({type:"resolve-stack",stack:stack,message:msg}))}catch(e){}}};',
+    "function showRuntimeError(title,errors,payload){",
+    "var a=document.getElementById('app');",
+    "if(V._recovering&&a&&a.innerHTML.length>50)return;",
+    "if(V._recovering)V._recovering=false;",
+    "V._hadClientError=true;",
+    "V.showOverlay(title,V.formatErrors(errors),payload,'client')}",
+    "if(V._recovering){setTimeout(function(){V._recovering=false},5000)}",
+    "window.addEventListener('error',function(e){",
+    "var msg=e.message||String(e.error);",
+    "var stk=e.error&&e.error.stack;",
+    "if(stk){V._sendResolveStack(stk,msg)}",
+    "var f=e.filename,isBundled=f&&(f.indexOf('/_bun/')!==-1||f.indexOf('blob:')!==-1);",
+    "var errInfo=isBundled?{message:msg}:{message:msg,file:f,line:e.lineno,column:e.colno};",
+    "showRuntimeError('Runtime error',[errInfo],{type:'error',category:'runtime',errors:[errInfo]})});",
+    "window.addEventListener('unhandledrejection',function(e){",
+    "var m=e.reason instanceof Error?e.reason.message:String(e.reason);",
+    "var stk=e.reason&&e.reason.stack;",
+    "if(stk){V._sendResolveStack(stk,m)}",
+    "showRuntimeError('Runtime error',[{message:m}],{type:'error',category:'runtime',errors:[{message:m}]})});",
+    "var hmrErr=false,origCE=console.error,origCL=console.log;",
+    "console.error=function(){",
+    "var t=Array.prototype.join.call(arguments,' ');",
+    "var hmr=t.match(/\\[vertz-hmr\\] Error re-mounting (\\w+): ([\\s\\S]*?)(?:\\n\\s+at |$)/);",
+    "if(hmr){hmrErr=true;V._hadClientError=true;",
+    "V.showOverlay('Runtime error',V.formatErrors([{message:hmr[2].split('\\n')[0]}]),{type:'error',category:'runtime',errors:[{message:hmr[2].split('\\n')[0]}]},'client')}",
+    "origCE.apply(console,arguments)};",
+    "console.log=function(){",
+    "var t=Array.prototype.join.call(arguments,' ');",
+    "if(t.indexOf('[vertz-hmr] Hot updated:')!==-1){",
+    "if(!hmrErr&&V._src==='client'){",
+    "V._hadClientError=false;V.removeOverlay();setTimeout(function(){var a=document.getElementById('app');if(!a||a.innerHTML.length<50){V._needsReload=true}},500)}",
+    "hmrErr=false}",
+    "origCL.apply(console,arguments)};",
+    "})()</script>"
+  ].join("");
+}
+var RELOAD_GUARD_SCRIPT = `<script>(function(){var K="__vertz_reload_count",T="__vertz_reload_ts",s=sessionStorage,n=parseInt(s.getItem(K)||"0",10),t=parseInt(s.getItem(T)||"0",10),now=Date.now();if(now-t<100){n++}else{n=1}s.setItem(K,String(n));s.setItem(T,String(now));if(n>10){window.stop();s.removeItem(K);s.removeItem(T);var d=document,o=d.createElement("div");o.style.cssText="position:fixed;inset:0;z-index:2147483647;display:flex;align-items:center;justify-content:center;background:rgba(0,0,0,0.6)";var c=d.createElement("div");c.style.cssText="background:#fff;color:#1a1a1a;border-radius:12px;padding:32px;max-width:480px;width:90%;font-family:system-ui,sans-serif;text-align:center;box-shadow:0 20px 60px rgba(0,0,0,0.3)";c.innerHTML='<div style="font-size:40px;margin-bottom:16px">&#9888;&#65039;</div><h2 style="margin:0 0 8px;font-size:20px">Dev server connection lost</h2><p style="margin:0 0 20px;color:#666;font-size:14px;line-height:1.5">The page reloaded 10+ times in rapid succession. This usually means the dev server stopped or a build failed.</p><button id="__vertz_retry" style="background:#2563eb;color:#fff;border:none;border-radius:8px;padding:10px 24px;font-size:14px;cursor:pointer">Retry</button>';o.appendChild(c);(d.body||d.documentElement).appendChild(o);d.getElementById("__vertz_retry").onclick=function(){location.href=location.href}}else{setTimeout(function(){s.removeItem(K);s.removeItem(T)},5e3)}})()</script>`;
+function generateSSRPageHtml({
+  title,
+  css,
+  bodyHtml,
+  ssrData,
+  scriptTag,
+  editor = "vscode"
+}) {
+  const ssrDataScript = ssrData.length > 0 ? `<script>window.__VERTZ_SSR_DATA__=${safeSerialize(ssrData)};</script>` : "";
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${title}</title>
+    ${css}
+    ${buildErrorChannelScript(editor)}
+    ${RELOAD_GUARD_SCRIPT}
+  </head>
+  <body>
+    <div id="app">${bodyHtml}</div>
+    ${ssrDataScript}
+    ${scriptTag}
+  </body>
+</html>`;
+}
+function createFetchInterceptor({
+  apiHandler,
+  origin,
+  skipSSRPaths,
+  originalFetch
+}) {
+  const intercepted = (input, init) => {
+    const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const isRelative = rawUrl.startsWith("/");
+    const fetchPath = isRelative ? rawUrl.split("?")[0] ?? "/" : new URL(rawUrl).pathname;
+    const isLocal = isRelative || new URL(rawUrl).origin === origin;
+    if (isLocal && skipSSRPaths.some((p) => fetchPath.startsWith(p))) {
+      const absoluteUrl = isRelative ? `${origin}${rawUrl}` : rawUrl;
+      const req = new Request(absoluteUrl, init);
+      return apiHandler(req);
+    }
+    return originalFetch(input, init);
+  };
+  intercepted.preconnect = originalFetch.preconnect;
+  return intercepted;
+}
+var BUILD_ERROR_LOADER = [
+  "(function(){",
+  "var el=document.querySelector('[data-bun-dev-server-script]');if(!el)return;var src=el.src;",
+  "var V=window.__vertz_overlay||{};",
+  `var formatErrors=V.formatErrors||function(){return'<p style="margin:0;color:#666;font-size:12px">Check your terminal for details.</p>'};`,
+  "var showOverlay=V.showOverlay||function(t,body){",
+  "var e=document.getElementById('__vertz_error');if(e)e.remove();",
+  "var d=document,c=d.createElement('div');c.id='__vertz_error';",
+  "c.style.cssText='position:fixed;bottom:16px;left:50%;transform:translateX(-50%);z-index:2147483647;background:#fff;color:#1a1a1a;border-radius:8px;padding:14px 16px;max-width:480px;width:calc(100% - 32px);font-family:system-ui,sans-serif;box-shadow:0 4px 24px rgba(0,0,0,0.12);border:1px solid #e5e5e5';",
+  `c.innerHTML='<div style="margin-bottom:10px;font-size:13px;font-weight:600;color:#dc2626">'+t+'</div>'+body+'<button onclick="location.reload()" style="margin-top:8px;background:#1a1a1a;color:#fff;border:none;border-radius:6px;padding:4px 12px;font-size:12px;cursor:pointer">Retry</button>';`,
+  "(d.body||d.documentElement).appendChild(c)};",
+  "el.remove();",
+  "fetch(src).then(function(r){return r.text()}).then(function(t){",
+  "if(t.trimStart().startsWith('try{location.reload()}')){",
+  "fetch('/__vertz_build_check').then(function(r){return r.json()}).then(function(j){",
+  "if(j.errors&&j.errors.length>0){showOverlay('Build failed',formatErrors(j.errors),j)}",
+  "else{var rk='__vertz_stub_retry',rc=+(sessionStorage.getItem(rk)||0);",
+  "if(rc<3){sessionStorage.setItem(rk,String(rc+1));setTimeout(function(){location.reload()},2000)}",
+  `else{sessionStorage.removeItem(rk);showOverlay('Build failed','<p style="margin:0;color:#666;font-size:12px">Could not load client bundle. Try reloading manually.</p>')}}`,
+  "}).catch(function(){",
+  `showOverlay('Build failed','<p style="margin:0;color:#666;font-size:12px">Check your terminal for details.</p>')})}`,
+  "else{sessionStorage.removeItem('__vertz_stub_retry');var s=document.createElement('script');s.type='module';s.crossOrigin='';s.src=src;document.body.appendChild(s)}",
+  `}).catch(function(){showOverlay('Dev server unreachable','<p style="margin:0;color:#666;font-size:12px">Could not connect. Is it still running?</p>')})`,
+  "})()"
+].join("");
+function buildScriptTag(bundledScriptUrl, hmrBootstrapScript, clientSrc) {
+  if (bundledScriptUrl) {
+    const placeholder = `<script type="text/plain" crossorigin src="${bundledScriptUrl}" data-bun-dev-server-script></script>`;
+    const bootstrap = hmrBootstrapScript ? `
+    ${hmrBootstrapScript}` : "";
+    const loader = `<script>${BUILD_ERROR_LOADER}</script>`;
+    return `${placeholder}${bootstrap}
+    ${loader}`;
+  }
+  return `<script type="module" src="${clientSrc}"></script>`;
+}
+function createBunDevServer(options) {
+  const {
+    entry,
+    port = 3000,
+    host = "localhost",
+    apiHandler,
+    skipSSRPaths = ["/api/"],
+    openapi,
+    clientEntry: clientEntryOption,
+    title = "Vertz App",
+    projectRoot = process.cwd(),
+    logRequests = true,
+    editor: editorOption
+  } = options;
+  const editor = detectEditor(editorOption);
+  const devDir = resolve(projectRoot, ".vertz", "dev");
+  mkdirSync(devDir, { recursive: true });
+  const logger = createDebugLogger(devDir);
+  const diagnostics = new DiagnosticsCollector;
+  let server = null;
+  let srcWatcherRef = null;
+  let refreshTimeout = null;
+  let stopped = false;
+  const wsClients = new Set;
+  let currentError = null;
+  const sourceMapResolver = createSourceMapResolver(projectRoot);
+  let clearGraceUntil = 0;
+  let runtimeDebounceTimer = null;
+  let pendingRuntimeError = null;
+  function broadcastError(category, errors) {
+    if (currentError?.category === "build" && category !== "build") {
+      return;
+    }
+    if (category === "runtime" && Date.now() < clearGraceUntil) {
+      return;
+    }
+    if (category === "runtime") {
+      if (!pendingRuntimeError || errors.some((e) => e.file)) {
+        pendingRuntimeError = errors;
+      }
+      if (!runtimeDebounceTimer) {
+        runtimeDebounceTimer = setTimeout(() => {
+          runtimeDebounceTimer = null;
+          const errs = pendingRuntimeError;
+          pendingRuntimeError = null;
+          if (errs) {
+            currentError = { category: "runtime", errors: errs };
+            const msg2 = JSON.stringify({ type: "error", category: "runtime", errors: errs });
+            for (const ws of wsClients) {
+              ws.sendText(msg2);
+            }
+          }
+        }, 100);
+      }
+      return;
+    }
+    currentError = { category, errors };
+    diagnostics.recordError(category, errors[0]?.message ?? "");
+    logger.log("ws", "broadcast-error", { category, errorCount: errors.length });
+    const msg = JSON.stringify({ type: "error", category, errors });
+    for (const ws of wsClients) {
+      ws.sendText(msg);
+    }
+  }
+  function clearError() {
+    if (currentError === null && !pendingRuntimeError)
+      return;
+    currentError = null;
+    diagnostics.recordErrorClear();
+    if (runtimeDebounceTimer) {
+      clearTimeout(runtimeDebounceTimer);
+      runtimeDebounceTimer = null;
+      pendingRuntimeError = null;
+    }
+    clearGraceUntil = Date.now() + 5000;
+    const msg = JSON.stringify({ type: "clear" });
+    for (const ws of wsClients) {
+      ws.sendText(msg);
+    }
+  }
+  function clearErrorForFileChange() {
+    if (currentError === null && !pendingRuntimeError)
+      return;
+    currentError = null;
+    diagnostics.recordErrorClear();
+    if (runtimeDebounceTimer) {
+      clearTimeout(runtimeDebounceTimer);
+      runtimeDebounceTimer = null;
+      pendingRuntimeError = null;
+    }
+    clearGraceUntil = 0;
+    const msg = JSON.stringify({ type: "clear" });
+    for (const ws of wsClients) {
+      ws.sendText(msg);
+    }
+  }
+  let lastBuildError = "";
+  let lastBroadcastedError = "";
+  let lastChangedFile = "";
+  const resolvePatterns = ["Could not resolve", "Module not found", "Cannot find module"];
+  const hmrErrorPattern = /\[vertz-hmr\] Error re-mounting (\w+): ([\s\S]*?)(?:\n\s+at |$)/;
+  const frontendErrorPattern = /\x1b\[31mfrontend\x1b\[0m ([\s\S]*?)(?:\n\s+from browser|$)/;
+  function parseSourceFromStack(text) {
+    const stackLines = text.split(`
+`);
+    const srcLine = stackLines.find((l) => l.includes("/src/") && !l.includes("node_modules"));
+    if (srcLine) {
+      const locMatch = srcLine.match(/(?:at .+? \(|at )(.+?):(\d+):(\d+)/);
+      if (locMatch) {
+        const absFile = locMatch[1];
+        const line = Number(locMatch[2]);
+        const lineText = absFile ? readLineText(absFile, line) : undefined;
+        return {
+          message: "",
+          file: absFile?.replace(projectRoot, "").replace(/^\//, ""),
+          absFile,
+          line,
+          column: Number(locMatch[3]),
+          lineText
+        };
+      }
+    }
+    return { message: "" };
+  }
+  const origConsoleError = console.error;
+  console.error = (...args) => {
+    const text = args.map((a) => typeof a === "string" ? a : String(a)).join(" ");
+    if (!text.startsWith("[Server]")) {
+      lastBuildError = text;
+      if (resolvePatterns.some((p) => text.includes(p)) && text !== lastBroadcastedError) {
+        lastBroadcastedError = text;
+        broadcastError("resolve", [{ message: text }]);
+      } else {
+        const hmrMatch = text.match(hmrErrorPattern);
+        if (hmrMatch && text !== lastBroadcastedError) {
+          lastBroadcastedError = text;
+          const component = hmrMatch[1];
+          const errorMsg = hmrMatch[2]?.trim() ?? "Unknown error";
+          const loc = parseSourceFromStack(text);
+          if (!loc.file && lastChangedFile) {
+            loc.file = lastChangedFile;
+            loc.absFile = resolve(projectRoot, lastChangedFile);
+          }
+          broadcastError("runtime", [
+            {
+              message: `${errorMsg} (in ${component})`,
+              file: loc.file,
+              absFile: loc.absFile,
+              line: loc.line,
+              column: loc.column,
+              lineText: loc.lineText
+            }
+          ]);
+        } else {
+          const feMatch = text.match(frontendErrorPattern);
+          if (feMatch && text !== lastBroadcastedError) {
+            lastBroadcastedError = text;
+            const errorMsg = feMatch[1]?.split(`
+`)[0]?.trim() ?? "Unknown error";
+            const loc = parseSourceFromStack(text);
+            if (!loc.file && lastChangedFile) {
+              loc.file = lastChangedFile;
+              loc.absFile = resolve(projectRoot, lastChangedFile);
+            }
+            broadcastError("runtime", [
+              {
+                message: errorMsg,
+                file: loc.file,
+                absFile: loc.absFile,
+                line: loc.line,
+                column: loc.column,
+                lineText: loc.lineText
+              }
+            ]);
+          }
+        }
+      }
+    }
+    origConsoleError.apply(console, args);
+  };
+  const indexHtmlStasher = createIndexHtmlStasher(projectRoot);
+  let cachedSpec = null;
+  let specWatcher = null;
+  const loadOpenAPISpec = () => {
+    if (!openapi)
+      return null;
+    try {
+      const specContent = readFileSync2(openapi.specPath, "utf-8");
+      return JSON.parse(specContent);
+    } catch (err) {
+      console.error("[Server] Error reading OpenAPI spec:", err);
+      return null;
+    }
+  };
+  const setupOpenAPIWatcher = () => {
+    if (!openapi || !existsSync(openapi.specPath))
+      return;
+    cachedSpec = loadOpenAPISpec();
+    if (cachedSpec === null)
+      return;
+    try {
+      const specDir = dirname(openapi.specPath);
+      const specFile = openapi.specPath.split("/").pop() || "openapi.json";
+      specWatcher = watch(specDir, { persistent: false }, (eventType, filename) => {
+        if (filename === specFile && (eventType === "change" || eventType === "rename")) {
+          if (logRequests) {
+            console.log("[Server] OpenAPI spec file changed, reloading...");
+          }
+          cachedSpec = loadOpenAPISpec();
+        }
+      });
+    } catch (err) {
+      console.warn("[Server] Could not set up file watcher for OpenAPI spec:", err);
+    }
+  };
+  const serveOpenAPISpec = () => {
+    if (cachedSpec) {
+      return new Response(JSON.stringify(cachedSpec), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (openapi && existsSync(openapi.specPath)) {
+      cachedSpec = loadOpenAPISpec();
+      if (cachedSpec) {
+        return new Response(JSON.stringify(cachedSpec), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    return new Response("OpenAPI spec not found", { status: 404 });
+  };
+  async function start() {
+    indexHtmlStasher.stash();
+    const { plugin } = await Promise.resolve(globalThis.Bun);
+    const { createVertzBunPlugin } = await import("./bun-plugin/index.js");
+    const entryPath = resolve(projectRoot, entry);
+    const rawClientSrc = clientEntryOption ?? entry;
+    const clientSrc = rawClientSrc.replace(/^\.\//, "/");
+    plugin({
+      name: "vertz-ssr-jsx-swap",
+      setup(build) {
+        build.onResolve({ filter: /^@vertz\/ui\/jsx-runtime$/ }, () => ({
+          path: "@vertz/ui-server/jsx-runtime",
+          external: false
+        }));
+        build.onResolve({ filter: /^@vertz\/ui\/jsx-dev-runtime$/ }, () => ({
+          path: "@vertz/ui-server/jsx-runtime",
+          external: false
+        }));
+      }
+    });
+    const { plugin: serverPlugin } = createVertzBunPlugin({
+      hmr: false,
+      fastRefresh: false,
+      logger,
+      diagnostics
+    });
+    plugin(serverPlugin);
+    let ssrMod;
+    try {
+      ssrMod = await import(entryPath);
+      if (logRequests) {
+        console.log("[Server] SSR module loaded");
+      }
+    } catch (e) {
+      console.error("[Server] Failed to load SSR module:", e);
+      process.exit(1);
+    }
+    mkdirSync(devDir, { recursive: true });
+    const frInitPath = resolve(devDir, "fast-refresh-init.ts");
+    writeFileSync2(frInitPath, `import '@vertz/ui-server/fast-refresh-runtime';
+if (import.meta.hot) import.meta.hot.accept();
+`);
+    const hmrShellHtml = `<!doctype html>
+<html lang="en"><head>
+  <meta charset="UTF-8" />
+  <title>HMR Shell</title>
+</head><body>
+  <script type="module" src="./fast-refresh-init.ts"></script>
+  <script type="module" src="${clientSrc}"></script>
+</body></html>`;
+    const hmrShellPath = resolve(devDir, "hmr-shell.html");
+    writeFileSync2(hmrShellPath, hmrShellHtml);
+    const hmrShellModule = __require(hmrShellPath);
+    setupOpenAPIWatcher();
+    let bundledScriptUrl = null;
+    let hmrBootstrapScript = null;
+    const routes = {
+      "/__vertz_hmr": hmrShellModule
+    };
+    if (openapi) {
+      routes["/api/openapi.json"] = () => serveOpenAPISpec();
+    }
+    if (apiHandler) {
+      routes["/api/*"] = (req) => apiHandler(req);
+    }
+    killStaleProcess(port);
+    server = Bun.serve({
+      port,
+      hostname: host,
+      routes,
+      async fetch(request) {
+        const url = new URL(request.url);
+        const pathname = url.pathname;
+        if (pathname === "/__vertz_errors") {
+          if (server?.upgrade(request, { data: {} })) {
+            return;
+          }
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+        if (pathname.startsWith("/_bun/")) {
+          return;
+        }
+        if (pathname === "/__vertz_build_check") {
+          if (currentError) {
+            return Response.json({ errors: currentError.errors });
+          }
+          try {
+            const clientRelative = rawClientSrc.replace(/^\//, "");
+            const result = await Bun.build({
+              entrypoints: [resolve(projectRoot, clientRelative)],
+              root: projectRoot,
+              target: "browser",
+              throw: false
+            });
+            if (!result.success && result.logs.length > 0) {
+              const errors = result.logs.filter((l) => l.level === "error").map((l) => {
+                const pos = l.position;
+                const file = pos?.file ? pos.file.replace(projectRoot, "").replace(/^\//, "") : undefined;
+                return {
+                  message: l.message,
+                  file,
+                  absFile: pos?.file,
+                  line: pos?.line,
+                  column: pos?.column,
+                  lineText: pos?.lineText
+                };
+              });
+              return Response.json({ errors });
+            }
+            if (lastBuildError) {
+              return Response.json({ errors: [{ message: lastBuildError }] });
+            }
+            return Response.json({ errors: [] });
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return Response.json({ errors: [{ message: msg }] });
+          }
+        }
+        if (pathname === "/__vertz_diagnostics") {
+          return Response.json(diagnostics.getSnapshot());
+        }
+        if (openapi && request.method === "GET" && pathname === "/api/openapi.json") {
+          return serveOpenAPISpec();
+        }
+        if (apiHandler && skipSSRPaths.some((p) => pathname.startsWith(p))) {
+          return apiHandler(request);
+        }
+        if (request.headers.get("x-vertz-nav") === "1") {
+          try {
+            const stream = await ssrStreamNavQueries(ssrMod, pathname, { navSsrTimeout: 5000 });
+            return new Response(stream, {
+              status: 200,
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache"
+              }
+            });
+          } catch {
+            return new Response(`event: done
+data: {}
+
+`, {
+              status: 200,
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache"
+              }
+            });
+          }
+        }
+        if (pathname !== "/" && !pathname.endsWith(".html")) {
+          const safePath = normalize(pathname).replace(/^(\.\.(\/|\\|$))+/, "");
+          const publicDir = resolve(projectRoot, "public");
+          const resolvedPublic = resolve(publicDir, safePath.slice(1));
+          if (resolvedPublic.startsWith(publicDir)) {
+            const publicFile = Bun.file(resolvedPublic);
+            if (await publicFile.exists()) {
+              return new Response(publicFile);
+            }
+          }
+          const resolvedRoot = resolve(projectRoot, safePath.slice(1));
+          if (resolvedRoot.startsWith(projectRoot)) {
+            const rootFile = Bun.file(resolvedRoot);
+            if (await rootFile.exists()) {
+              return new Response(rootFile);
+            }
+          }
+        }
+        if (!request.headers.get("accept")?.includes("text/html") && !pathname.endsWith(".html") && pathname !== "/") {
+          return new Response("Not Found", { status: 404 });
+        }
+        if (logRequests) {
+          console.log(`[Server] SSR: ${pathname}`);
+        }
+        try {
+          const originalFetch = globalThis.fetch;
+          if (apiHandler) {
+            globalThis.fetch = createFetchInterceptor({
+              apiHandler,
+              origin: `http://${host}:${server?.port}`,
+              skipSSRPaths,
+              originalFetch
+            });
+          }
+          try {
+            logger.log("ssr", "render-start", { url: pathname });
+            const ssrStart = performance.now();
+            const result = await ssrRenderToString(ssrMod, pathname, { ssrTimeout: 300 });
+            logger.log("ssr", "render-done", {
+              url: pathname,
+              durationMs: Math.round(performance.now() - ssrStart),
+              htmlBytes: result.html.length
+            });
+            const scriptTag = buildScriptTag(bundledScriptUrl, hmrBootstrapScript, clientSrc);
+            const html = generateSSRPageHtml({
+              title,
+              css: result.css,
+              bodyHtml: result.html,
+              ssrData: result.ssrData,
+              scriptTag,
+              editor
+            });
+            return new Response(html, {
+              status: 200,
+              headers: {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": "no-store"
+              }
+            });
+          } finally {
+            if (apiHandler) {
+              globalThis.fetch = originalFetch;
+            }
+          }
+        } catch (err) {
+          console.error("[Server] SSR error:", err);
+          const errMsg = err instanceof Error ? err.message : String(err);
+          const errStack = err instanceof Error ? err.stack : undefined;
+          const { message: _, ...loc } = errStack ? parseSourceFromStack(errStack) : { message: "" };
+          broadcastError("ssr", [{ message: errMsg, ...loc, stack: errStack }]);
+          const scriptTag = buildScriptTag(bundledScriptUrl, hmrBootstrapScript, clientSrc);
+          const fallbackHtml = generateSSRPageHtml({
+            title,
+            css: "",
+            bodyHtml: "",
+            ssrData: [],
+            scriptTag,
+            editor
+          });
+          return new Response(fallbackHtml, {
+            status: 200,
+            headers: {
+              "Content-Type": "text/html; charset=utf-8",
+              "Cache-Control": "no-store"
+            }
+          });
+        }
+      },
+      websocket: {
+        open(ws) {
+          wsClients.add(ws);
+          diagnostics.recordWebSocketChange(wsClients.size);
+          logger.log("ws", "client-connected", { total: wsClients.size });
+          ws.sendText(JSON.stringify({ type: "connected" }));
+          if (currentError) {
+            ws.sendText(JSON.stringify({
+              type: "error",
+              category: currentError.category,
+              errors: currentError.errors
+            }));
+          }
+        },
+        message(ws, msg) {
+          try {
+            const data = JSON.parse(typeof msg === "string" ? msg : new TextDecoder().decode(msg));
+            if (data.type === "ping") {
+              ws.sendText(JSON.stringify({ type: "pong" }));
+            } else if (data.type === "resolve-stack" && data.stack) {
+              const selfFetch = async (url) => {
+                const absUrl = url.startsWith("http") ? url : `http://${host}:${server?.port}${url}`;
+                return fetch(absUrl);
+              };
+              sourceMapResolver.resolveStack(data.stack, data.message ?? "", selfFetch).then((result) => {
+                const hasFileInfo = result.errors.some((e) => e.file);
+                if (!hasFileInfo) {
+                  const msg2 = result.errors[0]?.message ?? "";
+                  let enrichedErrors = null;
+                  if (currentError?.errors.some((e) => e.file)) {
+                    enrichedErrors = currentError.errors.map((e) => ({
+                      ...e,
+                      message: msg2 || e.message
+                    }));
+                  } else if (lastChangedFile) {
+                    const absFile = resolve(projectRoot, lastChangedFile);
+                    enrichedErrors = [{ message: msg2, file: lastChangedFile, absFile }];
+                  }
+                  if (enrichedErrors) {
+                    const payload2 = {
+                      type: "error",
+                      category: "runtime",
+                      errors: enrichedErrors,
+                      parsedStack: result.parsedStack
+                    };
+                    currentError = { category: "runtime", errors: enrichedErrors };
+                    const text2 = JSON.stringify(payload2);
+                    for (const client of wsClients) {
+                      client.sendText(text2);
+                    }
+                    return;
+                  }
+                }
+                const payload = {
+                  type: "error",
+                  category: "runtime",
+                  errors: result.errors,
+                  parsedStack: result.parsedStack
+                };
+                currentError = { category: "runtime", errors: result.errors };
+                const text = JSON.stringify(payload);
+                for (const client of wsClients) {
+                  client.sendText(text);
+                }
+              }).catch(() => {
+                let errors;
+                if (currentError?.errors.some((e) => e.file)) {
+                  errors = currentError.errors;
+                } else if (lastChangedFile) {
+                  const absFile = resolve(projectRoot, lastChangedFile);
+                  errors = [
+                    { message: data.message ?? "Unknown error", file: lastChangedFile, absFile }
+                  ];
+                }
+                if (errors) {
+                  const payload = {
+                    type: "error",
+                    category: "runtime",
+                    errors
+                  };
+                  currentError = { category: "runtime", errors };
+                  const text = JSON.stringify(payload);
+                  for (const client of wsClients) {
+                    client.sendText(text);
+                  }
+                } else {
+                  broadcastError("runtime", [{ message: data.message ?? "Unknown error" }]);
+                }
+              });
+            }
+          } catch {}
+        },
+        close(ws) {
+          wsClients.delete(ws);
+          diagnostics.recordWebSocketChange(wsClients.size);
+        }
+      },
+      development: {
+        hmr: true,
+        console: true
+      }
+    });
+    if (logRequests) {
+      console.log(`[Server] SSR+HMR dev server running at http://${host}:${server.port}`);
+    }
+    await discoverHMRAssets();
+    async function discoverHMRAssets() {
+      try {
+        const res = await fetch(`http://${host}:${server?.port}/__vertz_hmr`);
+        const html = await res.text();
+        const assets = parseHMRAssets(html);
+        if (assets.scriptUrl) {
+          bundledScriptUrl = assets.scriptUrl;
+          if (logRequests) {
+            console.log("[Server] Discovered bundled script URL:", bundledScriptUrl);
+          }
+        }
+        if (assets.bootstrapScript) {
+          hmrBootstrapScript = assets.bootstrapScript;
+          if (logRequests) {
+            console.log("[Server] Extracted HMR bootstrap script");
+          }
+        }
+        diagnostics.recordHMRAssets(bundledScriptUrl, hmrBootstrapScript !== null);
+      } catch (e) {
+        console.warn("[Server] Could not discover HMR bundled URL:", e);
+      }
+    }
+    const srcDir = resolve(projectRoot, "src");
+    stopped = false;
+    if (existsSync(srcDir)) {
+      srcWatcherRef = watch(srcDir, { recursive: true }, (_event, filename) => {
+        if (!filename)
+          return;
+        if (refreshTimeout)
+          clearTimeout(refreshTimeout);
+        refreshTimeout = setTimeout(async () => {
+          lastChangedFile = `src/${filename}`;
+          diagnostics.recordFileChange(lastChangedFile);
+          logger.log("watcher", "file-changed", { file: lastChangedFile });
+          lastBroadcastedError = "";
+          sourceMapResolver.invalidate();
+          if (logRequests) {
+            console.log(`[Server] File changed: ${filename}`);
+          }
+          if (stopped)
+            return;
+          await discoverHMRAssets();
+          if (stopped)
+            return;
+          try {
+            const clientRelative = rawClientSrc.replace(/^\//, "");
+            const result = await Bun.build({
+              entrypoints: [resolve(projectRoot, clientRelative)],
+              root: projectRoot,
+              target: "browser",
+              throw: false
+            });
+            if (!result.success && result.logs.length > 0) {
+              const errors = result.logs.filter((l) => l.level === "error").map((l) => {
+                const pos = l.position;
+                const file = pos?.file ? pos.file.replace(projectRoot, "").replace(/^\//, "") : undefined;
+                return {
+                  message: l.message,
+                  file,
+                  absFile: pos?.file,
+                  line: pos?.line,
+                  column: pos?.column,
+                  lineText: pos?.lineText
+                };
+              });
+              broadcastError("build", errors);
+            } else {
+              const prevUrl = bundledScriptUrl;
+              for (let attempt = 0;attempt < 5; attempt++) {
+                if (stopped)
+                  return;
+                await new Promise((r) => setTimeout(r, 200));
+                if (stopped)
+                  return;
+                await discoverHMRAssets();
+                if (bundledScriptUrl !== prevUrl)
+                  break;
+              }
+              clearErrorForFileChange();
+            }
+          } catch {}
+          if (stopped)
+            return;
+          const cacheKeys = Object.keys(__require.cache);
+          let cacheCleared = 0;
+          for (const key of cacheKeys) {
+            if (key.startsWith(srcDir) || key.startsWith(entryPath)) {
+              delete __require.cache[key];
+              cacheCleared++;
+            }
+          }
+          logger.log("watcher", "cache-cleared", { entries: cacheCleared });
+          const ssrWrapperPath = resolve(devDir, "ssr-reload-entry.ts");
+          mkdirSync(devDir, { recursive: true });
+          writeFileSync2(ssrWrapperPath, `export * from '${entryPath}';
+`);
+          const ssrReloadStart = performance.now();
+          try {
+            const freshMod = await import(`${ssrWrapperPath}?t=${Date.now()}`);
+            ssrMod = freshMod;
+            const durationMs = Math.round(performance.now() - ssrReloadStart);
+            diagnostics.recordSSRReload(true, durationMs);
+            logger.log("watcher", "ssr-reload", { status: "ok", durationMs });
+            if (logRequests) {
+              console.log("[Server] SSR module refreshed");
+            }
+          } catch {
+            logger.log("watcher", "ssr-reload", { status: "retry" });
+            if (stopped)
+              return;
+            await new Promise((r) => setTimeout(r, 500));
+            if (stopped)
+              return;
+            const retryKeys = Object.keys(__require.cache);
+            for (const key of retryKeys) {
+              if (key.startsWith(srcDir) || key.startsWith(entryPath)) {
+                delete __require.cache[key];
+              }
+            }
+            mkdirSync(devDir, { recursive: true });
+            writeFileSync2(ssrWrapperPath, `export * from '${entryPath}';
+`);
+            try {
+              const freshMod = await import(`${ssrWrapperPath}?t=${Date.now()}`);
+              ssrMod = freshMod;
+              const durationMs = Math.round(performance.now() - ssrReloadStart);
+              diagnostics.recordSSRReload(true, durationMs);
+              logger.log("watcher", "ssr-reload", { status: "ok", durationMs, retry: true });
+              if (logRequests) {
+                console.log("[Server] SSR module refreshed (retry)");
+              }
+            } catch (e2) {
+              console.error("[Server] Failed to refresh SSR module:", e2);
+              const errMsg = e2 instanceof Error ? e2.message : String(e2);
+              const errStack = e2 instanceof Error ? e2.stack : undefined;
+              const durationMs = Math.round(performance.now() - ssrReloadStart);
+              diagnostics.recordSSRReload(false, durationMs, errMsg);
+              logger.log("watcher", "ssr-reload", { status: "failed", error: errMsg });
+              const { message: _m, ...loc2 } = errStack ? parseSourceFromStack(errStack) : { message: "" };
+              broadcastError("ssr", [{ message: errMsg, ...loc2, stack: errStack }]);
+            }
+          }
+        }, 100);
+      });
+    }
+  }
+  return {
+    start,
+    broadcastError,
+    clearError,
+    clearErrorForFileChange,
+    setLastChangedFile(file) {
+      lastChangedFile = file;
+    },
+    async stop() {
+      stopped = true;
+      if (refreshTimeout) {
+        clearTimeout(refreshTimeout);
+        refreshTimeout = null;
+      }
+      if (specWatcher) {
+        specWatcher.close();
+        specWatcher = null;
+      }
+      if (srcWatcherRef) {
+        srcWatcherRef.close();
+        srcWatcherRef = null;
+      }
+      if (server) {
+        server.stop(true);
+        server = null;
+      }
+      indexHtmlStasher.restore();
+    }
+  };
+}
+export {
+  parseHMRAssets,
+  generateSSRPageHtml,
+  createIndexHtmlStasher,
+  createFetchInterceptor,
+  createBunDevServer,
+  buildScriptTag
+};