gorsee 0.2.4 → 0.2.6

package/dist-pkg/runtime/project.js

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+export function resolveProjectPaths(cwd, overrides = {}) {
+  const gorseeDir = join(cwd, ".gorsee"), distDir = join(cwd, "dist");
+  return { ...{
+    cwd,
+    routesDir: join(cwd, "routes"),
+    publicDir: join(cwd, "public"),
+    distDir,
+    clientDir: join(distDir, "client"),
+    serverDir: join(distDir, "server"),
+    gorseeDir,
+    sharedDir: join(cwd, "shared"),
+    middlewareDir: join(cwd, "middleware"),
+    migrationsDir: join(cwd, "migrations"),
+    docsDir: join(cwd, "docs"),
+    dataFile: join(cwd, "data.sqlite"),
+    appConfigFile: join(cwd, "app.config.ts")
+  }, ...overrides, cwd };
+}
+export function createProjectContext(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return {
+    cwd,
+    env: options.env ?? process.env,
+    paths: resolveProjectPaths(cwd, options.pathOverrides)
+  };
+}
+export function resolveRuntimeEnv(env) {
+  return {
+    port: Number(env.PORT || "3000"),
+    logLevel: env.LOG_LEVEL === "debug" ? "debug" : "info",
+    rateLimit: Number(env.RATE_LIMIT) || 1000,
+    rateWindow: env.RATE_WINDOW || "1m",
+    isProduction: env.NODE_ENV === "production"
+  };
+}

package/dist-pkg/runtime/renderable.d.ts

@@ -0,0 +1,6 @@
+export type GorseePrimitive = string | number | boolean | null | undefined;
+export type GorseeVNodeLike = {
+    type: string | symbol | ((props: Record<string, unknown>) => GorseeRenderable);
+    props: Record<string, unknown>;
+};
+export type GorseeRenderable = Node | DocumentFragment | GorseePrimitive | GorseeVNodeLike | GorseeRenderable[] | (() => unknown);

package/dist-pkg/runtime/router.d.ts

@@ -0,0 +1,47 @@
+type NavigateCallback = (url: string) => void;
+type BeforeNavigateCallback = (url: string) => boolean | void;
+type PreservedControlState = {
+    key: string;
+    mode: "value" | "checked";
+    value: string | boolean;
+};
+type HMRUpdate = {
+    kind: "full-reload" | "route-refresh" | "css-update";
+    changedPath: string;
+    timestamp: number;
+    reason?: string;
+    routePaths?: string[];
+    entryScripts?: string[];
+    refreshCurrentRoute?: boolean;
+};
+export interface RouterNavigationDiagnostics {
+    currentPath: string;
+    navigating: boolean;
+    pendingPopScrollY: number | null;
+    latestNavigationToken: number;
+    activeNavigation: {
+        url: string;
+        pushState: boolean;
+    } | null;
+}
+export interface NavigationSnapshot {
+    focusKey?: string;
+    controls: PreservedControlState[];
+}
+export declare function createHTMLFragment(html: string): DocumentFragment;
+export declare function replaceHTMLFragment(container: Element, html: string): void;
+export declare function captureNavigationSnapshot(container: Element): NavigationSnapshot;
+export declare function restoreNavigationSnapshot(container: Element, snapshot: NavigationSnapshot): void;
+/** Set a loading indicator element to show during navigation */
+export declare function setLoadingElement(el: HTMLElement): void;
+export declare function onNavigate(fn: NavigateCallback): () => void;
+export declare function beforeNavigate(fn: BeforeNavigateCallback): () => void;
+export declare function getCurrentPath(): string;
+export declare function getRouterNavigationDiagnostics(): RouterNavigationDiagnostics;
+export declare function setCurrentRouteScript(script: string | null | undefined): void;
+export declare function navigate(url: string, pushState?: boolean): Promise<void>;
+export declare function refreshCurrentRoute(): Promise<void>;
+export declare function applyHMRUpdate(update: HMRUpdate): Promise<void>;
+export declare function prefetch(url: string): void;
+export declare function initRouter(): void;
+export {};

package/dist-pkg/runtime/router.js

@@ -0,0 +1,487 @@
+import { hydrate } from "./client.js";
+let currentPath = "";
+const subscribers = [], beforeNavigateHooks = [];
+let navigating = !1, loadingElement = null, activeNavigationController = null, latestNavigationToken = 0, pendingPopScrollY = null, activeNavigationUrl = null, activeNavigationPushState = !0, lastFocusedPreserveKey = null, currentRouteScript = null, initializedDocument = null, initializedWindow = null;
+export function createHTMLFragment(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+export function replaceHTMLFragment(container, html) {
+  const fragment = createHTMLFragment(html);
+  container.replaceChildren(...Array.from(fragment.childNodes));
+}
+function getPreserveKey(element) {
+  if (!element)
+    return null;
+  const preserveKey = element.getAttribute("data-g-preserve-key");
+  if (preserveKey)
+    return preserveKey;
+  if ("name" in element && typeof element.name === "string" && element.name)
+    return element.name;
+  if ("id" in element && typeof element.id === "string" && element.id)
+    return element.id;
+  return null;
+}
+function isCheckableInput(element) {
+  return "type" in element && element.type === "checkbox";
+}
+function isFormControlElement(element) {
+  if (!element)
+    return !1;
+  const tagName = element.tagName?.toLowerCase();
+  return tagName === "input" || tagName === "textarea" || tagName === "select";
+}
+function getFocusablePreserveKey(element) {
+  if (!element)
+    return null;
+  if (element.getAttribute("data-g-preserve-key"))
+    return getPreserveKey(element);
+  if (isFormControlElement(element))
+    return getPreserveKey(element);
+  return null;
+}
+function getControlSelector(key) {
+  return `[data-g-preserve-key="${key}"], [name="${key}"], #${key}`;
+}
+function focusPreservedTarget(target) {
+  const focusable = target, runFocus = () => {
+    if (focusable.isConnected === !1)
+      return !1;
+    if (typeof focusable.focus === "function")
+      focusable.focus?.();
+    else if (typeof HTMLElement < "u" && target instanceof HTMLElement)
+      HTMLElement.prototype.focus.call(target);
+    if (typeof document > "u" || !("activeElement" in document))
+      return !1;
+    return document.activeElement === target;
+  };
+  if (runFocus())
+    return;
+  const retryDelays = [0, 16, 48, 96, 160];
+  for (const delayMs of retryDelays)
+    setTimeout(() => {
+      if (typeof document < "u" && "activeElement" in document && document.activeElement === target)
+        return;
+      runFocus();
+    }, delayMs);
+  if (typeof requestAnimationFrame === "function")
+    requestAnimationFrame(() => {
+      if (typeof document < "u" && "activeElement" in document && document.activeElement === target)
+        return;
+      runFocus();
+    });
+}
+function schedulePostNavigationFocusRestore(container, snapshot) {
+  const focusKey = snapshot.focusKey ?? snapshot.controls[0]?.key;
+  if (!focusKey)
+    return;
+  const selector = getControlSelector(focusKey), commit = () => {
+    const target = container.querySelector(selector);
+    if (!target)
+      return;
+    focusPreservedTarget(target);
+    lastFocusedPreserveKey = focusKey;
+  };
+  commit();
+  if (typeof requestAnimationFrame === "function")
+    requestAnimationFrame(() => commit());
+  setTimeout(() => commit(), 32);
+}
+export function captureNavigationSnapshot(container) {
+  const controls = [], activeFocusKey = typeof container.contains === "function" && container.contains(document.activeElement) ? getFocusablePreserveKey(document.activeElement) ?? void 0 : void 0, formControls = typeof container.querySelectorAll === "function" ? container.querySelectorAll("input, textarea, select") : [];
+  for (const control of formControls) {
+    const key = getPreserveKey(control);
+    if (!key)
+      continue;
+    if (isCheckableInput(control)) {
+      controls.push({ key, mode: "checked", value: control.checked });
+      continue;
+    }
+    if ("value" in control && typeof control.value === "string")
+      controls.push({ key, mode: "value", value: control.value });
+  }
+  return { focusKey: activeFocusKey ?? lastFocusedPreserveKey ?? controls[0]?.key, controls };
+}
+export function restoreNavigationSnapshot(container, snapshot) {
+  for (const controlState of snapshot.controls) {
+    const control = container.querySelector(getControlSelector(controlState.key));
+    if (!control)
+      continue;
+    if (controlState.mode === "checked" && "checked" in control) {
+      control.checked = controlState.value === !0;
+      continue;
+    }
+    if (controlState.mode === "value" && "value" in control && typeof controlState.value === "string")
+      control.value = controlState.value;
+  }
+  const focusKey = snapshot.focusKey ?? snapshot.controls[0]?.key;
+  if (focusKey) {
+    const focusTarget = container.querySelector(getControlSelector(focusKey));
+    if (focusTarget) {
+      focusPreservedTarget(focusTarget);
+      lastFocusedPreserveKey = focusKey;
+    }
+  }
+}
+function readCurrentScrollY() {
+  if (typeof window > "u")
+    return 0;
+  if (typeof window.scrollY === "number")
+    return window.scrollY;
+  const windowWithPageOffset = window;
+  if (typeof windowWithPageOffset.pageYOffset === "number")
+    return windowWithPageOffset.pageYOffset;
+  return 0;
+}
+function rememberCurrentHistoryScroll(url) {
+  if (typeof history > "u" || typeof history.replaceState !== "function")
+    return;
+  const currentState = typeof history.state === "object" && history.state !== null ? history.state : {};
+  history.replaceState({
+    ...currentState,
+    gorsee: !0,
+    gorseeScrollY: readCurrentScrollY()
+  }, "", url);
+}
+function applyNavigationScroll(pushState) {
+  if (pushState) {
+    window.scrollTo(0, 0);
+    return;
+  }
+  if (pendingPopScrollY !== null) {
+    window.scrollTo(0, pendingPopScrollY);
+    pendingPopScrollY = null;
+  }
+}
+export function setLoadingElement(el) {
+  loadingElement = el;
+}
+function showLoading() {
+  if (loadingElement) {
+    loadingElement.style.display = "";
+    loadingElement.removeAttribute("hidden");
+  }
+}
+function hideLoading() {
+  if (loadingElement)
+    loadingElement.style.display = "none";
+}
+export function onNavigate(fn) {
+  subscribers.push(fn);
+  return () => {
+    const i = subscribers.indexOf(fn);
+    if (i >= 0)
+      subscribers.splice(i, 1);
+  };
+}
+export function beforeNavigate(fn) {
+  beforeNavigateHooks.push(fn);
+  return () => {
+    const i = beforeNavigateHooks.indexOf(fn);
+    if (i >= 0)
+      beforeNavigateHooks.splice(i, 1);
+  };
+}
+export function getCurrentPath() {
+  return currentPath;
+}
+export function getRouterNavigationDiagnostics() {
+  return {
+    currentPath,
+    navigating,
+    pendingPopScrollY,
+    latestNavigationToken,
+    activeNavigation: activeNavigationController && activeNavigationUrl ? { url: activeNavigationUrl, pushState: activeNavigationPushState } : null
+  };
+}
+async function fetchPage(url, signal) {
+  const res = await fetch(url, {
+    headers: {
+      Accept: "application/json",
+      "X-Gorsee-Navigate": "partial"
+    },
+    signal
+  });
+  if (!res.ok)
+    throw Error(`Navigation failed: ${res.status}`);
+  return res.json();
+}
+function updateHead(result) {
+  if (result.title)
+    document.title = result.title;
+  document.querySelectorAll("link[data-g-route-css]").forEach((el) => el.remove());
+  if (result.css)
+    for (const href of result.css) {
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = href;
+      link.dataset.gRouteCss = "";
+      document.head.appendChild(link);
+    }
+}
+function updateDataScript(result) {
+  let dataEl = document.getElementById("__GORSEE_DATA__");
+  if (result.data !== void 0) {
+    if (!dataEl) {
+      const script = document.createElement("script");
+      script.id = "__GORSEE_DATA__";
+      script.type = "application/json";
+      document.body.appendChild(script);
+      dataEl = script;
+    }
+    dataEl.textContent = JSON.stringify(result.data);
+  } else if (dataEl)
+    dataEl.remove();
+  if (result.params)
+    globalThis.__GORSEE_PARAMS__ = result.params;
+}
+function normalizeRouteScript(script) {
+  if (!script)
+    return null;
+  try {
+    return new URL(script, location.origin).pathname;
+  } catch {
+    return script;
+  }
+}
+export function setCurrentRouteScript(script) {
+  currentRouteScript = normalizeRouteScript(script);
+  globalThis.__GORSEE_ROUTE_SCRIPT__ = currentRouteScript;
+}
+async function navigateInternal(url, pushState, force = !1) {
+  if (!force && url === currentPath)
+    return;
+  for (const hook of beforeNavigateHooks)
+    try {
+      if (hook(url) === !1)
+        return;
+    } catch {
+      return;
+    }
+  const container = document.getElementById("app"), snapshot = container ? captureNavigationSnapshot(container) : { controls: [] };
+  if (pushState)
+    rememberCurrentHistoryScroll(currentPath || location.pathname + location.search);
+  activeNavigationController?.abort();
+  const controller = new AbortController;
+  activeNavigationController = controller;
+  activeNavigationUrl = url;
+  activeNavigationPushState = pushState;
+  const navigationToken = ++latestNavigationToken;
+  navigating = !0;
+  showLoading();
+  try {
+    const result = await fetchPage(url, controller.signal);
+    if (controller.signal.aborted || navigationToken !== latestNavigationToken)
+      return;
+    if (!container)
+      return;
+    replaceHTMLFragment(container, result.html);
+    updateHead(result);
+    updateDataScript(result);
+    if (result.script)
+      setCurrentRouteScript(result.script);
+    restoreNavigationSnapshot(container, snapshot);
+    if (pushState)
+      history.pushState({ gorsee: !0 }, "", url);
+    currentPath = url;
+    if (result.script) {
+      globalThis.__GORSEE_SUPPRESS_ENTRY_BOOTSTRAP__ = !0;
+      let mod;
+      try {
+        mod = await import(result.script);
+      } finally {
+        globalThis.__GORSEE_SUPPRESS_ENTRY_BOOTSTRAP__ = !1;
+      }
+      if (controller.signal.aborted || navigationToken !== latestNavigationToken)
+        return;
+      const renderRoute = mod.default;
+      if (renderRoute && typeof renderRoute === "function") {
+        const data = result.data ?? {}, params = result.params ?? {};
+        hydrate(() => renderRoute({ data, params }), container);
+        restoreNavigationSnapshot(container, snapshot);
+      }
+    }
+    applyNavigationScroll(pushState);
+    for (const fn of subscribers)
+      fn(url);
+    observeViewportPrefetchAnchors(container);
+    schedulePostNavigationFocusRestore(container, snapshot);
+  } catch (error) {
+    if (controller.signal.aborted)
+      return;
+    throw error;
+  } finally {
+    if (activeNavigationController === controller) {
+      activeNavigationController = null;
+      activeNavigationUrl = null;
+      activeNavigationPushState = !0;
+      hideLoading();
+      navigating = !1;
+    }
+  }
+}
+export async function navigate(url, pushState = !0) {
+  await navigateInternal(url, pushState, !1);
+}
+export async function refreshCurrentRoute() {
+  const target = currentPath || readLocationPath();
+  if (!target)
+    return;
+  await navigateInternal(target, !1, !0);
+}
+function refreshStylesheets(timestamp) {
+  const links = document.querySelectorAll?.('link[rel="stylesheet"]') ?? [];
+  for (const link of links) {
+    if (!("href" in link) || typeof link.href !== "string")
+      continue;
+    try {
+      const nextURL = new URL(link.href, location.origin);
+      if (nextURL.origin !== location.origin)
+        continue;
+      nextURL.searchParams.set("gorsee-hmr", String(timestamp));
+      link.href = nextURL.toString();
+    } catch {}
+  }
+}
+function currentPathMatchesRoute(routePath) {
+  return (readLocationPath().split("?")[0] ?? readLocationPath()) === routePath;
+}
+function hmrTouchesCurrentRoute(update) {
+  if (update.refreshCurrentRoute)
+    return !0;
+  if (update.entryScripts?.length && currentRouteScript)
+    return update.entryScripts.some((script) => normalizeRouteScript(script) === currentRouteScript);
+  if (update.routePaths?.length)
+    return update.routePaths.some((routePath) => currentPathMatchesRoute(routePath));
+  return !1;
+}
+export async function applyHMRUpdate(update) {
+  if (!update || typeof update.kind !== "string") {
+    location.reload();
+    return;
+  }
+  if (update.kind === "full-reload") {
+    location.reload();
+    return;
+  }
+  if (update.kind === "css-update")
+    refreshStylesheets(update.timestamp);
+  if (!hmrTouchesCurrentRoute(update))
+    return;
+  await refreshCurrentRoute();
+}
+const prefetchCache = new Set, observedViewportPrefetchAnchors = new WeakSet;
+let viewportPrefetchObserver = null;
+function normalizePrefetchURL(url) {
+  const [withoutHash] = url.split("#", 1);
+  return withoutHash || url;
+}
+export function prefetch(url) {
+  const normalizedURL = normalizePrefetchURL(url);
+  if (prefetchCache.has(normalizedURL))
+    return;
+  prefetchCache.add(normalizedURL);
+  const link = document.createElement("link");
+  link.rel = "prefetch";
+  link.href = normalizedURL;
+  link.setAttribute("as", "fetch");
+  link.setAttribute("crossorigin", "");
+  document.head.appendChild(link);
+}
+function ensureViewportPrefetchObserver() {
+  if (viewportPrefetchObserver)
+    return viewportPrefetchObserver;
+  if (typeof IntersectionObserver > "u")
+    return null;
+  viewportPrefetchObserver = new IntersectionObserver((entries) => {
+    for (const entry of entries) {
+      if (!entry.isIntersecting)
+        continue;
+      const target = entry.target;
+      prefetch(target.pathname + target.search);
+      viewportPrefetchObserver?.unobserve(target);
+    }
+  }, {
+    rootMargin: "200px"
+  });
+  return viewportPrefetchObserver;
+}
+function observeViewportPrefetchAnchors(root = document) {
+  const observer = ensureViewportPrefetchObserver();
+  if (!observer || typeof root.querySelectorAll !== "function")
+    return;
+  const anchors = root.querySelectorAll('a[data-g-prefetch="viewport"][href]');
+  for (const anchor of anchors) {
+    if (!anchor || typeof anchor !== "object" || observedViewportPrefetchAnchors.has(anchor))
+      continue;
+    observedViewportPrefetchAnchors.add(anchor);
+    observer.observe(anchor);
+  }
+}
+function shouldHandleClick(e, anchor) {
+  if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey)
+    return !1;
+  if (e.button !== 0)
+    return !1;
+  if (anchor.target && anchor.target !== "_self")
+    return !1;
+  if (anchor.origin !== location.origin)
+    return !1;
+  if (anchor.hasAttribute("download"))
+    return !1;
+  if (anchor.pathname === location.pathname && anchor.search === location.search && anchor.hash)
+    return !1;
+  return !0;
+}
+function readLocationPath() {
+  return `${location.pathname}${location.search}`;
+}
+export function initRouter() {
+  currentPath = readLocationPath();
+  setCurrentRouteScript(globalThis.__GORSEE_ROUTE_SCRIPT__);
+  globalThis.__gorseeHandleHMR = (update) => {
+    applyHMRUpdate(update);
+  };
+  if (typeof history.replaceState === "function") {
+    const currentState = typeof history.state === "object" && history.state !== null ? history.state : {};
+    history.replaceState({
+      ...currentState,
+      gorsee: !0,
+      gorseeScrollY: readCurrentScrollY()
+    }, "", readLocationPath());
+  }
+  if (initializedDocument !== document) {
+    initializedDocument = document;
+    document.addEventListener("click", (e) => {
+      const anchor = e.target.closest?.("a[href]");
+      if (!anchor)
+        return;
+      if (anchor.dataset.gNoRouter !== void 0)
+        return;
+      if (shouldHandleClick(e, anchor)) {
+        e.preventDefault();
+        navigate(anchor.pathname + anchor.search);
+      }
+    });
+    document.addEventListener("focusin", (e) => {
+      const target = e.target, container = document.getElementById("app");
+      if (!target || !container || !container.contains(target))
+        return;
+      const key = getFocusablePreserveKey(target);
+      if (key)
+        lastFocusedPreserveKey = key;
+    });
+  }
+  if (initializedWindow !== window) {
+    initializedWindow = window;
+    window.addEventListener("popstate", (e) => {
+      const nextPath = readLocationPath();
+      if (e.state?.gorsee || currentPath !== nextPath) {
+        pendingPopScrollY = typeof e.state?.gorseeScrollY === "number" ? e.state.gorseeScrollY : 0;
+        navigate(nextPath, !1);
+      }
+    });
+  }
+  observeViewportPrefetchAnchors(document);
+}

package/dist-pkg/runtime/server.d.ts

@@ -0,0 +1,8 @@
+import type { Component } from "./jsx-runtime.js";
+export type VNode = {
+    type: string | Component | symbol;
+    props: Record<string, unknown>;
+};
+export declare function ssrJsx(type: string | Component | symbol, props: Record<string, unknown> | null): VNode;
+export declare const ssrJsxs: typeof ssrJsx;
+export declare function renderToString(root: unknown): string;

package/dist-pkg/runtime/server.js

@@ -0,0 +1,71 @@
+import { escapeHTML, escapeAttr, isRenderableThunk, VOID_ELEMENTS, resolveValue } from "./html-escape.js";
+function renderChild(child) {
+  if (child == null || typeof child === "boolean")
+    return "";
+  if (Array.isArray(child)) {
+    let s = "";
+    for (let i = 0;i < child.length; i++)
+      s += renderChild(child[i]);
+    return s;
+  }
+  if (typeof child === "object" && child !== null && "type" in child)
+    return renderVNode(child);
+  if (isRenderableThunk(child))
+    return renderChild(child());
+  const resolved = resolveValue(child);
+  if (resolved == null || typeof resolved === "boolean")
+    return "";
+  return escapeHTML(String(resolved));
+}
+function renderAttrs(props) {
+  let result = "";
+  for (const key in props) {
+    if (key === "children" || key === "ref" || key.startsWith("on:"))
+      continue;
+    const value = resolveValue(props[key]);
+    if (key === "className" || key === "class") {
+      if (value != null)
+        result += ` class="${escapeAttr(String(value))}"`;
+      continue;
+    }
+    if (key === "style" && typeof value === "object" && value !== null) {
+      let styles = "";
+      for (const p in value) {
+        if (styles)
+          styles += "; ";
+        const sv = resolveValue(value[p]);
+        if (sv != null)
+          styles += `${p}: ${sv}`;
+      }
+      result += ` style="${escapeAttr(styles)}"`;
+      continue;
+    }
+    if (typeof value === "boolean") {
+      if (value)
+        result += ` ${key}`;
+    } else if (value != null)
+      result += ` ${key}="${escapeAttr(String(value))}"`;
+  }
+  return result;
+}
+function renderVNode(vnode) {
+  const { type, props } = vnode;
+  if (typeof type === "symbol")
+    return renderChild(props.children);
+  if (typeof type === "function") {
+    const result = type(props);
+    return renderChild(result);
+  }
+  const tag = type, attrs = renderAttrs(props);
+  if (VOID_ELEMENTS.has(tag))
+    return `<${tag}${attrs} />`;
+  const children = renderChild(props.children);
+  return `<${tag}${attrs}>${children}</${tag}>`;
+}
+export function ssrJsx(type, props) {
+  return { type, props: props ?? {} };
+}
+export const ssrJsxs = ssrJsx;
+export function renderToString(root) {
+  return renderChild(root);
+}

package/dist-pkg/runtime/stream.d.ts

@@ -0,0 +1,29 @@
+import type { Component } from "./jsx-runtime.js";
+interface SuspenseSlot {
+    id: string;
+    fallback: unknown;
+    children: unknown;
+    resolve: () => Promise<unknown>;
+}
+interface StreamContext {
+    suspenseSlots: SuspenseSlot[];
+    nextId: number;
+}
+interface VNode {
+    type: string | Component | symbol;
+    props: Record<string, unknown>;
+    __gorsee_suspense?: boolean;
+}
+export declare function streamJsx(type: string | Component | symbol, props: Record<string, unknown> | null): VNode;
+export declare const streamJsxs: typeof streamJsx;
+export declare function StreamSuspense(props: {
+    fallback: unknown;
+    children: unknown;
+    __streamCtx?: StreamContext;
+}): VNode;
+export declare function buildStreamChunkScript(slotId: string, html: string): string;
+export interface StreamOptions {
+    shell?: (body: string) => string;
+}
+export declare function renderToStream(root: unknown, options?: StreamOptions): ReadableStream<Uint8Array>;
+export {};