gorsee 0.2.4 → 0.2.5

package/dist-pkg/runtime/router.js

@@ -0,0 +1,476 @@
+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;
+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;
+export function prefetch(url) {
+  if (prefetchCache.has(url))
+    return;
+  prefetchCache.add(url);
+  const link = document.createElement("link");
+  link.rel = "prefetch";
+  link.href = url;
+  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.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());
+  }
+  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;
+  });
+  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 {};

package/dist-pkg/runtime/stream.js

@@ -0,0 +1,106 @@
+import { escapeHTML, escapeAttr, VOID_ELEMENTS, resolveValue } from "./html-escape.js";
+export function streamJsx(type, props) {
+  return { type, props: props ?? {} };
+}
+export const streamJsxs = streamJsx;
+export function StreamSuspense(props) {
+  const node = streamJsx("gorsee-suspense", {
+    fallback: props.fallback,
+    children: props.children
+  });
+  node.__gorsee_suspense = !0;
+  return node;
+}
+function renderAttrs(props) {
+  const parts = [];
+  for (const [key, rawValue] of Object.entries(props)) {
+    if (key === "children" || key === "ref" || key === "fallback" || key.startsWith("on:"))
+      continue;
+    const value = resolveValue(rawValue);
+    if (key === "className" || key === "class") {
+      if (value != null)
+        parts.push(` class="${escapeAttr(String(value))}"`);
+    } else if (typeof value === "boolean") {
+      if (value)
+        parts.push(` ${key}`);
+    } else if (value != null)
+      parts.push(` ${key}="${escapeAttr(String(value))}"`);
+  }
+  return parts.join("");
+}
+function renderShellNode(node, ctx) {
+  if (node == null || typeof node === "boolean")
+    return "";
+  if (Array.isArray(node))
+    return node.map((n) => renderShellNode(n, ctx)).join("");
+  if (typeof node === "object" && node !== null && "type" in node) {
+    const vnode = node;
+    if (vnode.__gorsee_suspense) {
+      const id = `s${ctx.nextId++}`, fallbackHtml = renderShellNode(vnode.props.fallback, ctx);
+      ctx.suspenseSlots.push({
+        id,
+        fallback: vnode.props.fallback,
+        children: vnode.props.children,
+        resolve: async () => {
+          const children = vnode.props.children;
+          if (typeof children === "function")
+            return await children();
+          return children;
+        }
+      });
+      return `<div data-g-suspense="${id}">${fallbackHtml}</div>`;
+    }
+    if (typeof vnode.type === "symbol")
+      return renderShellNode(vnode.props.children, ctx);
+    if (typeof vnode.type === "function") {
+      const result = vnode.type(vnode.props);
+      return renderShellNode(result, ctx);
+    }
+    const tag = vnode.type, attrs = renderAttrs(vnode.props);
+    if (VOID_ELEMENTS.has(tag))
+      return `<${tag}${attrs} />`;
+    const children = renderShellNode(vnode.props.children, ctx);
+    return `<${tag}${attrs}>${children}</${tag}>`;
+  }
+  const resolved = resolveValue(node);
+  if (resolved == null || typeof resolved === "boolean")
+    return "";
+  return escapeHTML(String(resolved));
+}
+export function buildStreamChunkScript(slotId, html) {
+  return [
+    `<template data-g-chunk="${slotId}">${html}</template>`,
+    "<script>",
+    "(function(){",
+    `  var t=document.querySelector('[data-g-chunk="${slotId}"]');`,
+    `  var s=document.querySelector('[data-g-suspense="${slotId}"]');`,
+    "  if(t&&s){var f=t.content.cloneNode(true);s.replaceChildren(...Array.from(f.childNodes));t.remove();s.removeAttribute('data-g-suspense')}",
+    "})();",
+    "</script>"
+  ].join("");
+}
+const defaultShell = (body) => `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="UTF-8" /><meta name="viewport" content="width=device-width, initial-scale=1.0" /><title>Gorsee App</title></head>
+<body><div id="app">${body}</div>`, STREAM_TAIL = "</body></html>";
+export function renderToStream(root, options) {
+  const shell = options?.shell ?? defaultShell, encoder = new TextEncoder, ctx = { suspenseSlots: [], nextId: 0 };
+  return new ReadableStream({
+    async start(controller) {
+      const shellHtml = renderShellNode(root, ctx);
+      controller.enqueue(encoder.encode(shell(shellHtml)));
+      const promises = ctx.suspenseSlots.map(async (slot) => {
+        try {
+          const resolved = await slot.resolve(), html = renderShellNode(resolved, ctx), script = buildStreamChunkScript(slot.id, html);
+          controller.enqueue(encoder.encode(script));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err), errorHtml = `<div class="error">Error: ${escapeHTML(message)}</div>`, script = buildStreamChunkScript(slot.id, errorHtml);
+          controller.enqueue(encoder.encode(script));
+        }
+      });
+      await Promise.all(promises);
+      controller.enqueue(encoder.encode(STREAM_TAIL));
+      controller.close();
+    }
+  });
+}

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

@@ -0,0 +1,6 @@
+import type { GorseeRenderable } from "./renderable.js";
+export interface SuspenseProps {
+    fallback: GorseeRenderable;
+    children: GorseeRenderable;
+}
+export declare function Suspense(props: SuspenseProps): GorseeRenderable;