weifuwu 0.18.2 → 0.18.4

package/dist/dist/react.js

@@ -0,0 +1,637 @@
+// use-websocket.ts
+import { useEffect, useRef, useCallback, useState } from "react";
+var RECONNECT_DELAY = 3e3;
+var MAX_RETRIES = 10;
+function resolveUrl(url) {
+  return typeof url === "function" ? url() : url;
+}
+function useWebsocket(url, options) {
+  const { onMessage, reconnect: reconnectOpt = true, protocols, enabled = true } = options ?? {};
+  const [lastMessage, setLastMessage] = useState(null);
+  const [readyState, setReadyState] = useState(WebSocket.CLOSED);
+  const wsRef = useRef(null);
+  const retryRef = useRef(0);
+  const timerRef = useRef(void 0);
+  const mountedRef = useRef(true);
+  const shouldReconnectRef = useRef(true);
+  const urlRef = useRef(url);
+  const optsRef = useRef({ onMessage, reconnectOpt, protocols });
+  urlRef.current = url;
+  optsRef.current = { onMessage, reconnectOpt, protocols };
+  const cleanup = useCallback(() => {
+    clearTimeout(timerRef.current);
+    wsRef.current?.close();
+    wsRef.current = null;
+  }, []);
+  const connect = useCallback(() => {
+    if (!mountedRef.current || !enabled) return;
+    const resolved = resolveUrl(urlRef.current);
+    if (!resolved) return;
+    wsRef.current?.close();
+    const ws = new WebSocket(resolved, optsRef.current.protocols);
+    wsRef.current = ws;
+    setReadyState(WebSocket.CONNECTING);
+    ws.addEventListener("open", () => {
+      if (!mountedRef.current) return;
+      retryRef.current = 0;
+      setReadyState(WebSocket.OPEN);
+    });
+    ws.addEventListener("message", (e) => {
+      if (!mountedRef.current) return;
+      const data = typeof e.data === "string" ? e.data : String(e.data);
+      setLastMessage(data);
+      optsRef.current.onMessage?.(data);
+    });
+    ws.addEventListener("close", () => {
+      if (!mountedRef.current) return;
+      setReadyState(WebSocket.CLOSED);
+      const ro = optsRef.current.reconnectOpt;
+      if (ro && shouldReconnectRef.current && mountedRef.current) {
+        const maxRetries = typeof ro === "object" ? ro.maxRetries ?? MAX_RETRIES : MAX_RETRIES;
+        const delay = typeof ro === "object" ? ro.delay ?? RECONNECT_DELAY : RECONNECT_DELAY;
+        if (retryRef.current < maxRetries) {
+          retryRef.current++;
+          timerRef.current = setTimeout(() => connect(), delay);
+        }
+      }
+    });
+  }, [enabled]);
+  useEffect(() => {
+    mountedRef.current = true;
+    shouldReconnectRef.current = true;
+    if (enabled) connect();
+    return () => {
+      mountedRef.current = false;
+      cleanup();
+    };
+  }, [enabled, connect, cleanup]);
+  const send = useCallback((data) => {
+    wsRef.current?.send(data);
+  }, []);
+  const close = useCallback(() => {
+    shouldReconnectRef.current = false;
+    cleanup();
+    setReadyState(WebSocket.CLOSED);
+  }, [cleanup]);
+  const reconnectFn = useCallback(() => {
+    retryRef.current = 0;
+    shouldReconnectRef.current = true;
+    cleanup();
+    connect();
+  }, [cleanup, connect]);
+  return { send, close, readyState, lastMessage, reconnect: reconnectFn };
+}
+
+// use-action.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2 } from "react";
+function getCsrfToken() {
+  if (typeof document === "undefined") return void 0;
+  const match = document.cookie.match(/(?:^|;\s*)_csrf=([^;]+)/);
+  return match ? decodeURIComponent(match[1]) : void 0;
+}
+function useAction(url, options) {
+  const { method = "POST", headers, onSuccess, onError } = options ?? {};
+  const [data, setData] = useState2(null);
+  const [error, setError] = useState2(null);
+  const [pending, setPending] = useState2(false);
+  const mountedRef = useRef2(true);
+  const submit = useCallback2(async (body) => {
+    setPending(true);
+    setError(null);
+    try {
+      const csrfToken = getCsrfToken();
+      const hdrs = { ...headers };
+      if (csrfToken) hdrs["x-csrf-token"] = csrfToken;
+      if (body && typeof body === "object" && !(body instanceof FormData)) {
+        hdrs["content-type"] = "application/json";
+      }
+      const res = await fetch(url, {
+        method,
+        headers: hdrs,
+        body: body instanceof FormData ? body : body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(text || `HTTP ${res.status}`);
+      }
+      const result = res.status === 204 ? void 0 : await res.json();
+      if (mountedRef.current) {
+        setData(result);
+        onSuccess?.(result);
+      }
+      return result;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      if (mountedRef.current) {
+        setError(e);
+        onError?.(e);
+      }
+      return void 0;
+    } finally {
+      if (mountedRef.current) setPending(false);
+    }
+  }, [url, method, headers, onSuccess, onError]);
+  const reset = useCallback2(() => {
+    setData(null);
+    setError(null);
+  }, []);
+  return { submit, data, error, pending, reset };
+}
+
+// client-router.ts
+import { createElement, useCallback as useCallback3, useState as useState3, useEffect as useEffect2 } from "react";
+
+// client-pref.ts
+var interceptors = [];
+function addInterceptor(fn) {
+  interceptors.push(fn);
+}
+async function runInterceptors(url) {
+  for (const fn of interceptors) {
+    if (await fn(url)) return true;
+  }
+  return false;
+}
+
+// client-router.ts
+var _navigating = false;
+var _listeners = [];
+function onNavigate(fn) {
+  _listeners.push(fn);
+  return () => {
+    _listeners = _listeners.filter((l) => l !== fn);
+  };
+}
+function setNavigating(v) {
+  _navigating = v;
+  for (const fn of _listeners) fn(v);
+}
+async function navigate(href) {
+  if (typeof document === "undefined") return;
+  const url = new URL(href, location.origin);
+  if (url.origin !== location.origin) {
+    location.href = href;
+    return;
+  }
+  if (await runInterceptors(url)) return;
+  const scrollPos = [window.scrollX, window.scrollY];
+  setNavigating(true);
+  try {
+    const html = await fetch(url.pathname + url.search, {
+      headers: { accept: "text/html" }
+    }).then((r) => r.text());
+    const doc = new DOMParser().parseFromString(html, "text/html");
+    const rootEl = doc.getElementById("__weifuwu_root");
+    if (!rootEl) {
+      location.href = href;
+      return;
+    }
+    const newHtml = rootEl.innerHTML;
+    const propsMatch = html.match(/window\.__WEIFUWU_PROPS=(.+?)<\/script>/);
+    if (!propsMatch) {
+      location.href = href;
+      return;
+    }
+    const bundleMatch = html.match(/src="(\/__wfw\/client\/[^"]+\.js)"/);
+    const bundleUrl = bundleMatch ? bundleMatch[1] : null;
+    applyHead(html);
+    const currentRoot = document.getElementById("__weifuwu_root");
+    if (!currentRoot) {
+      location.href = href;
+      return;
+    }
+    ;
+    window.__WEIFUWU_PROPS = JSON.parse(propsMatch[1]);
+    history.pushState(null, "", url.pathname + url.search);
+    currentRoot.innerHTML = newHtml;
+    const ctxMatch = html.match(/window\.__WEIFUWU_CTX=(.+?)<\/script>/);
+    if (ctxMatch) {
+      try {
+        window.__WEIFUWU_CTX = JSON.parse(ctxMatch[1]);
+      } catch {
+      }
+    }
+    const localeMatch = html.match(/window\.__LOCALE_DATA__=(.+?)<\/script>/);
+    if (localeMatch) {
+      try {
+        window.__LOCALE_DATA__ = JSON.parse(localeMatch[1]);
+      } catch {
+      }
+    }
+    if (bundleUrl) {
+      try {
+        await import(
+          /* @vite-ignore */
+          `${bundleUrl}`
+        );
+      } catch (e) {
+        console.error("[weifuwu/router] hydration failed:", e);
+        location.href = href;
+      }
+    }
+    window.scrollTo(scrollPos[0], scrollPos[1]);
+  } finally {
+    setNavigating(false);
+  }
+}
+function applyHead(html) {
+  const match = html.match(/<template id="__wfw_head">([\s\S]*?)<\/template>/);
+  if (!match) return;
+  const headHtml = match[1];
+  const titleMatch = headHtml.match(/<title>([^<]*)<\/title>/);
+  if (titleMatch) document.title = titleMatch[1];
+  const doc = new DOMParser().parseFromString(headHtml, "text/html");
+  const newMeta = doc.querySelectorAll("meta");
+  const existing = document.querySelectorAll("head meta");
+  const newNames = new Set(Array.from(newMeta).map((m) => m.getAttribute("name") || m.getAttribute("property") || ""));
+  for (const el of existing) {
+    const key = el.getAttribute("name") || el.getAttribute("property") || "";
+    if (!newNames.has(key)) el.remove();
+  }
+  for (const el of newMeta) {
+    const key = el.getAttribute("name") || el.getAttribute("property") || "";
+    let existingEl = null;
+    if (key) {
+      for (const m of document.head.querySelectorAll("meta")) {
+        if (m.getAttribute("name") === key || m.getAttribute("property") === key) {
+          existingEl = m;
+          break;
+        }
+      }
+    }
+    if (existingEl) {
+      for (const attr of el.attributes) existingEl.setAttribute(attr.name, attr.value);
+    } else {
+      document.head.appendChild(el.cloneNode());
+    }
+  }
+  const newLink = doc.querySelector('link[rel="canonical"]');
+  const existingLink = document.querySelector('link[rel="canonical"]');
+  if (newLink) {
+    if (existingLink) existingLink.setAttribute("href", newLink.getAttribute("href") || "");
+    else document.head.appendChild(newLink.cloneNode());
+  } else if (existingLink) {
+    existingLink.remove();
+  }
+}
+function useNavigate() {
+  return useCallback3((href) => navigate(href), []);
+}
+function useNavigating() {
+  const [v, setV] = useState3(false);
+  useEffect2(() => onNavigate(setV), []);
+  return v;
+}
+var prefetchCache = /* @__PURE__ */ new Map();
+var PREFETCH_TTL = 6e4;
+function Link({ href, children, onClick, prefetch, ...props }) {
+  const doNavigate = useNavigate();
+  useEffect2(() => {
+    if (!prefetch) return;
+    let el = document.querySelector(`a[href="${CSS.escape(href)}"]`);
+    if (!el) {
+      for (const a of document.querySelectorAll("a")) {
+        if (a.getAttribute("href") === href) {
+          el = a;
+          break;
+        }
+      }
+    }
+    if (!el) return;
+    const observer = new IntersectionObserver(([entry]) => {
+      if (entry.isIntersecting) prefetchPage(href);
+    }, { rootMargin: "200px" });
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [href, prefetch]);
+  const handleMouseEnter = useCallback3(() => {
+    if (prefetch) prefetchPage(href);
+  }, [href, prefetch]);
+  const handleClick = useCallback3((e) => {
+    if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+    e.preventDefault();
+    doNavigate(href);
+    onClick?.(e);
+  }, [href, onClick, doNavigate]);
+  return createElement("a", {
+    href,
+    onClick: handleClick,
+    onMouseEnter: handleMouseEnter,
+    ...props
+  }, children);
+}
+async function prefetchPage(href) {
+  const cached = prefetchCache.get(href);
+  if (cached && Date.now() - cached.fetched < PREFETCH_TTL) return;
+  try {
+    const html = await fetch(href, { headers: { accept: "text/html" } }).then((r) => r.text());
+    prefetchCache.set(href, { html, fetched: Date.now() });
+  } catch {
+  }
+}
+
+// tsx-context.ts
+import { createContext } from "react";
+var DEFAULT_CTX = { params: {}, query: {}, parsed: {}, prefs: {}, loaderData: {}, env: {}, user: {} };
+var KEY = "__WEIFUWU_CTX_STORE";
+function getStore() {
+  if (typeof globalThis !== "undefined" && globalThis[KEY]) {
+    return globalThis[KEY];
+  }
+  const s = {
+    _ctx: DEFAULT_CTX,
+    _snapshot: { params: DEFAULT_CTX.params, query: DEFAULT_CTX.query, user: DEFAULT_CTX.user, parsed: DEFAULT_CTX.parsed, prefs: DEFAULT_CTX.prefs, env: DEFAULT_CTX.env },
+    _listeners: /* @__PURE__ */ new Set(),
+    _alsGetStore: null
+  };
+  if (typeof globalThis !== "undefined") {
+    globalThis[KEY] = s;
+  }
+  return s;
+}
+var store = getStore();
+function setCtx(value) {
+  store._ctx = { ...store._ctx, ...value };
+  store._snapshot = { params: store._ctx.params, query: store._ctx.query, user: store._ctx.user, parsed: store._ctx.parsed, prefs: store._ctx.prefs, env: store._ctx.env };
+  store._listeners.forEach((fn) => fn());
+}
+function useCtx() {
+  const alsStore = store._alsGetStore?.();
+  const base = alsStore ?? store._ctx;
+  const data = typeof window !== "undefined" ? window.__WEIFUWU_CTX : null;
+  return { ...base, ...data };
+}
+function useLoaderData() {
+  const alsStore = store._alsGetStore?.();
+  const base = alsStore ?? store._ctx;
+  const data = typeof window !== "undefined" ? window.__WEIFUWU_CTX : null;
+  return { ...base, ...data }.loaderData;
+}
+var TsxContext = createContext(DEFAULT_CTX);
+
+// head.tsx
+import { createElement as createElement2 } from "react";
+function Head({ children }) {
+  return createElement2("template", { id: "__wfw_head" }, children);
+}
+
+// client-state.ts
+import { useSyncExternalStore as useSyncExternalStore2, useCallback as useCallback4, useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
+function createStore(initial) {
+  let state = { ...initial };
+  const listeners = /* @__PURE__ */ new Set();
+  const getState = () => state;
+  const setState = (partial) => {
+    const next = typeof partial === "function" ? partial(state) : partial;
+    state = { ...state, ...next };
+    listeners.forEach((fn) => fn());
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  const useStore = ((selector) => useSyncExternalStore2(
+    subscribe,
+    () => selector ? selector(state) : state
+  ));
+  useStore.getState = getState;
+  useStore.setState = setState;
+  useStore.subscribe = subscribe;
+  return useStore;
+}
+var dataCache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+var CACHE_TTL = 6e4;
+function useFetch(url, options) {
+  const ttl = options?.ttl ?? CACHE_TTL;
+  const [state, setState] = useState4({
+    data: options?.fallback,
+    loading: !options?.fallback && !!url
+  });
+  const urlRef = useRef3(url);
+  urlRef.current = url;
+  useEffect3(() => {
+    if (!url) {
+      setState({ data: void 0, loading: false });
+      return;
+    }
+    if (typeof window === "undefined") return;
+    const u = url;
+    let cancelled = false;
+    const cached = dataCache.get(u);
+    if (cached && Date.now() - cached.timestamp < ttl) {
+      if (!cancelled) setState({
+        data: cached.data,
+        error: cached.error,
+        loading: false
+      });
+      return;
+    }
+    async function doFetch() {
+      if (!inflight.has(u)) {
+        inflight.set(u, fetch(u).then((r) => {
+          if (!r.ok) throw new Error(r.statusText || `HTTP ${r.status}`);
+          return r.json();
+        }));
+      }
+      const promise = inflight.get(u);
+      try {
+        const data = await promise;
+        dataCache.set(u, { data, error: null, timestamp: Date.now() });
+        if (!cancelled) setState({ data, loading: false });
+      } catch (err) {
+        dataCache.set(u, { data: null, error: err, timestamp: Date.now() });
+        if (!cancelled) setState({ error: err, loading: false });
+      }
+    }
+    doFetch();
+    return () => {
+      cancelled = true;
+    };
+  }, [url, ttl]);
+  const mutate = useCallback4(async (data) => {
+    const u = urlRef.current;
+    if (!u) return;
+    const uStr = u;
+    if (data !== void 0) {
+      dataCache.set(uStr, { data, error: null, timestamp: Date.now() });
+      setState({ data, loading: false, error: void 0 });
+      return;
+    }
+    inflight.delete(uStr);
+    try {
+      const res = await fetch(uStr);
+      if (!res.ok) throw new Error(res.statusText || `HTTP ${res.status}`);
+      const newData = await res.json();
+      dataCache.set(uStr, { data: newData, error: null, timestamp: Date.now() });
+      setState({ data: newData, loading: false, error: void 0 });
+    } catch (err) {
+      setState({ error: err, loading: false });
+    }
+  }, []);
+  return { data: state.data, error: state.error, loading: state.loading, mutate };
+}
+function notifyQueryListeners() {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new PopStateEvent("popstate"));
+}
+function useQueryState(key, defaultValue = "") {
+  function getSnapshot() {
+    if (typeof window === "undefined") return defaultValue;
+    const params = new URLSearchParams(window.location.search);
+    return params.get(key) ?? defaultValue;
+  }
+  const value = useSyncExternalStore2(
+    (cb) => {
+      if (typeof window === "undefined") return () => {
+      };
+      window.addEventListener("popstate", cb);
+      return () => window.removeEventListener("popstate", cb);
+    },
+    getSnapshot,
+    () => defaultValue
+  );
+  const setValue = useCallback4((val) => {
+    if (typeof window === "undefined") return;
+    const resolved = typeof val === "function" ? val(getSnapshot()) : val;
+    const url = new URL(window.location.href);
+    if (resolved === defaultValue || resolved === "") {
+      url.searchParams.delete(key);
+    } else {
+      url.searchParams.set(key, resolved);
+    }
+    window.history.replaceState(null, "", url.toString());
+    notifyQueryListeners();
+  }, [key, defaultValue]);
+  return [value, setValue];
+}
+
+// client-locale.ts
+function buildT() {
+  const messages = typeof window !== "undefined" ? window.__LOCALE_DATA__ : globalThis.__LOCALE_DATA__;
+  if (!messages) return (key, _p, fb) => fb ?? key;
+  return (key, params, fallback) => {
+    const msg = key.split(".").reduce((o, k) => o?.[k], messages);
+    if (msg === void 0 || msg === null) return fallback ?? key;
+    if (!params) return String(msg);
+    let result = String(msg);
+    for (const [k, v] of Object.entries(params)) result = result.replace(`{${k}}`, v);
+    return result;
+  };
+}
+addInterceptor(async (url) => {
+  const m = url.pathname.match(/^\/__lang\/(\w+)$/);
+  if (!m) return false;
+  try {
+    const res = await fetch(url.pathname, {
+      headers: { accept: "application/json" }
+    });
+    const data = await res.json();
+    const ctx = { ...window.__WEIFUWU_CTX || {}, params: {}, query: {} };
+    ctx.prefs = { ...ctx.prefs, locale: data.locale };
+    if (data.messages) window.__LOCALE_DATA__ = data.messages;
+    window.__WEIFUWU_CTX = ctx;
+    setCtx(ctx);
+  } catch {
+    location.href = url.href;
+  }
+  return true;
+});
+function useLocale() {
+  const ctx = useCtx();
+  return {
+    locale: ctx.prefs.locale,
+    setLocale: (locale) => navigate("/__lang/" + locale),
+    t: buildT()
+  };
+}
+
+// client-theme.ts
+import { useEffect as useEffect4 } from "react";
+function resolveTheme(theme) {
+  if (theme === "system") {
+    if (typeof window === "undefined") return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  }
+  return theme;
+}
+var _mqListener = null;
+function applyTheme(theme) {
+  if (typeof document === "undefined") return;
+  const resolved = resolveTheme(theme);
+  document.documentElement.dataset.theme = resolved;
+  if (theme === "system") {
+    if (!_mqListener) {
+      const mq = window.matchMedia("(prefers-color-scheme: dark)");
+      mq.addEventListener("change", (e) => {
+        if (window.__WEIFUWU_CTX?.prefs?.theme === "system") {
+          document.documentElement.dataset.theme = e.matches ? "dark" : "light";
+        }
+      });
+      _mqListener = mq;
+    }
+  }
+}
+addInterceptor(async (url) => {
+  const m = url.pathname.match(/^\/__theme\/(\w+)$/);
+  if (!m) return false;
+  try {
+    const res = await fetch(url.pathname, {
+      headers: { accept: "application/json" }
+    });
+    const data = await res.json();
+    const ctx = { ...window.__WEIFUWU_CTX || {}, params: {}, query: {} };
+    ctx.prefs = { ...ctx.prefs, theme: data.theme };
+    window.__WEIFUWU_CTX = ctx;
+    applyTheme(data.theme);
+    setCtx(ctx);
+  } catch {
+    location.href = url.href;
+  }
+  return true;
+});
+function useTheme() {
+  const ctx = useCtx();
+  const theme = ctx.prefs.theme ?? "system";
+  useEffect4(() => {
+    applyTheme(theme);
+  }, [theme]);
+  return {
+    theme,
+    resolvedTheme: resolveTheme(theme),
+    setTheme: (t) => navigate("/__theme/" + t)
+  };
+}
+
+// use-flash-message.ts
+import { useState as useState5 } from "react";
+function useFlashMessage() {
+  const [flash] = useState5(() => {
+    if (typeof window === "undefined") return null;
+    const raw = window.__WEIFUWU_CTX?.prefs?.flash;
+    if (!raw) return null;
+    return typeof raw === "string" ? JSON.parse(raw) : raw;
+  });
+  return flash;
+}
+export {
+  Head,
+  Link,
+  TsxContext,
+  addInterceptor,
+  applyTheme,
+  createStore,
+  navigate,
+  useAction,
+  useFetch,
+  useFlashMessage,
+  useLoaderData,
+  useLocale,
+  useNavigate,
+  useNavigating,
+  useQueryState,
+  useTheme,
+  useWebsocket
+};

package/dist/dist/request-id.d.ts

@@ -0,0 +1,6 @@
+import type { Middleware } from './types.ts';
+export interface RequestIdOptions {
+    header?: string;
+    generator?: () => string;
+}
+export declare function requestId(options?: RequestIdOptions): Middleware;

package/dist/dist/seo.d.ts

@@ -0,0 +1,39 @@
+import type { Middleware } from './types.ts';
+import { Router } from './router.ts';
+export interface RobotsRule {
+    userAgent?: string;
+    allow?: string | string[];
+    disallow?: string | string[];
+}
+export interface SitemapUrl {
+    loc: string;
+    lastmod?: string;
+    changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+    priority?: number;
+}
+export interface SitemapConfig {
+    urls?: SitemapUrl[];
+    resolve?: () => SitemapUrl[] | Promise<SitemapUrl[]>;
+    cacheTTL?: number;
+}
+export interface SeoHeadersConfig {
+    'X-Robots-Tag'?: string | ((path: string) => string | undefined);
+}
+export interface SeoOptions {
+    robots?: RobotsRule[];
+    sitemap?: SitemapConfig;
+    headers?: SeoHeadersConfig;
+    baseUrl?: string;
+}
+export declare function seoMiddleware(options?: SeoOptions): Middleware;
+export declare function seo(options?: SeoOptions): Router;
+export interface SeoTagsConfig {
+    title?: string;
+    description?: string;
+    ogImage?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    twitterCard?: 'summary' | 'summary_large_image';
+    canonical?: string;
+}
+export declare function seoTags(config: SeoTagsConfig): string;

package/dist/dist/ssr/compile.d.ts

@@ -0,0 +1,2 @@
+export declare function clearCompileCache(): void;
+export declare function compileTsx(path: string): Promise<any>;

package/dist/{ssr → dist/ssr}/index.d.ts

@@ -1,4 +1,4 @@
-export { ssr, ssrBundleHandler } from './ssr.ts';
+export { ssr } from './ssr.ts';
 export { layout } from './layout.ts';
 export { tailwind } from './tailwind.ts';
 export { notFound } from './not-found.ts';