@solidjs/web 2.0.0-experimental.8 → 2.0.0-rc.0

package/dist/server.js

@@ -1,10 +1,36 @@
-import { createMemo, sharedConfig, createRoot, ssrHandleError, omit } from 'solid-js';
-export { ErrorBoundary, For, Match, Repeat, Show, Suspense, Switch, createComponent, createRenderEffect as effect, getOwner, ssrRunInScope, untrack } from 'solid-js';
+import { createRenderEffect, createMemo, sharedConfig, createRoot, getOwner, ssrHandleError, runWithOwner, inServerComponentScope, creationStamp, createComponent, omit, getNextChildId, onCleanup, getProjectionTrace } from 'solid-js';
+export { Errored, For, Hydration, Loading, Match, NoHydration, Repeat, Reveal, Show, Switch, createComponent, getOwner, merge as mergeProps, ssrScope as scope, untrack } from 'solid-js';
 import { Feature, Serializer, getCrossReferenceHeader } from 'seroval';
 import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
 
-const Properties = /*#__PURE__*/new Set([
-"value", "checked", "selected", "muted"]);
+const DOMWithState = {
+  INPUT: {
+    value: 1,
+    defaultValue: 2,
+    checked: 1,
+    defaultChecked: 2
+  },
+  SELECT: {
+    value: 1
+  },
+  OPTION: {
+    value: 1,
+    selected: 1,
+    defaultSelected: 2
+  },
+  TEXTAREA: {
+    value: 1,
+    defaultValue: 2
+  },
+  VIDEO: {
+    muted: 1,
+    defaultMuted: 2
+  },
+  AUDIO: {
+    muted: 1,
+    defaultMuted: 2
+  }
+};
 const ChildProperties = /*#__PURE__*/new Set(["innerHTML", "textContent", "innerText", "children"]);
 const DelegatedEvents = /*#__PURE__*/new Set(["beforeinput", "click", "dblclick", "contextmenu", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]);
 const SVGElements = /*#__PURE__*/new Set([
@@ -12,52 +38,882 @@ const SVGElements = /*#__PURE__*/new Set([
 "set", "stop",
 "svg", "switch", "symbol", "text", "textPath",
 "tref", "tspan", "use", "view", "vkern"]);
-const SVGNamespace = {
+const MathMLElements = /*#__PURE__*/new Set(["annotation", "annotation-xml", "maction", "math", "menclose", "merror", "mfenced", "mfrac", "mi", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mprescripts", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msubsup", "msup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "semantics"]);
+const Namespaces = {
+  svg: "http://www.w3.org/2000/svg",
+  mathml: "http://www.w3.org/1998/Math/MathML",
   xlink: "http://www.w3.org/1999/xlink",
   xml: "http://www.w3.org/XML/1998/namespace"
 };
-const DOMElements = /*#__PURE__*/new Set(["html", "base", "head", "link", "meta", "style", "title", "body", "address", "article", "aside", "footer", "header", "main", "nav", "section", "body", "blockquote", "dd", "div", "dl", "dt", "figcaption", "figure", "hr", "li", "ol", "p", "pre", "ul", "a", "abbr", "b", "bdi", "bdo", "br", "cite", "code", "data", "dfn", "em", "i", "kbd", "mark", "q", "rp", "rt", "ruby", "s", "samp", "small", "span", "strong", "sub", "sup", "time", "u", "var", "wbr", "area", "audio", "img", "map", "track", "video", "embed", "iframe", "object", "param", "picture", "portal", "source", "svg", "math", "canvas", "noscript", "script", "del", "ins", "caption", "col", "colgroup", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "button", "datalist", "fieldset", "form", "input", "label", "legend", "meter", "optgroup", "option", "output", "progress", "select", "textarea", "details", "dialog", "menu", "summary", "details", "slot", "template", "acronym", "applet", "basefont", "bgsound", "big", "blink", "center", "content", "dir", "font", "frame", "frameset", "hgroup", "image", "keygen", "marquee", "menuitem", "nobr", "noembed", "noframes", "plaintext", "rb", "rtc", "shadow", "spacer", "strike", "tt", "xmp", "a", "abbr", "acronym", "address", "applet", "area", "article", "aside", "audio", "b", "base", "basefont", "bdi", "bdo", "bgsound", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "font", "footer", "form", "frame", "frameset", "head", "header", "hgroup", "hr", "html", "i", "iframe", "image", "img", "input", "ins", "kbd", "keygen", "label", "legend", "li", "link", "main", "map", "mark", "marquee", "menu", "menuitem", "meta", "meter", "nav", "nobr", "noembed", "noframes", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "plaintext", "portal", "pre", "progress", "q", "rb", "rp", "rt", "rtc", "ruby", "s", "samp", "script", "section", "select", "shadow", "slot", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "tt", "u", "ul", "var", "video", "wbr", "xmp", "input", "h1", "h2", "h3", "h4", "h5", "h6",
-"webview",
-"isindex", "listing", "multicol", "nextid", "noindex", "search"]);
+const VoidElements = /*#__PURE__*/new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+const RawTextElements = /*#__PURE__*/new Set(["style", "script", "noscript", "template", "textarea", "title"]);
+const DOMElements = /*#__PURE__*/new Set(/*#__PURE__*/"a,abbr,acronym,address,applet,area,article,aside,audio,b,base,basefont,bdi,bdo,bgsound,big,blink,blockquote,body,br,button,canvas,caption,center,cite,code,col,colgroup,content,data,datalist,dd,del,details,dfn,dialog,dir,div,dl,dt,em,embed,fieldset,figcaption,figure,font,footer,form,frame,frameset,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,i,iframe,image,img,input,ins,isindex,kbd,keygen,label,legend,li,link,listing,main,map,mark,marquee,math,menu,menuitem,meta,meter,multicol,nav,nextid,nobr,noembed,noframes,noindex,noscript,object,ol,optgroup,option,output,p,param,picture,plaintext,portal,pre,progress,q,rb,rp,rt,rtc,ruby,s,samp,script,search,section,select,shadow,slot,small,source,spacer,span,strike,strong,style,sub,summary,sup,svg,table,tbody,td,template,textarea,tfoot,th,thead,time,title,tr,track,tt,u,ul,var,video,wbr,webview,xmp".split(","));
 
-const memo = fn => createMemo(() => fn());
+const transparentOptions = {
+  transparent: true,
+  sync: true
+};
+const syncOptions = {
+  sync: true
+};
+const effect = (fn, effectFn, options) => createRenderEffect(fn, effectFn, options ? {
+  sync: true,
+  ...options,
+  transparent: !options.scope
+} : transparentOptions);
+const memo = fn => createMemo(() => fn(), syncOptions);
 
-const ES2017FLAG = Feature.AggregateError
-| Feature.BigIntTypedArray;
-const GLOBAL_IDENTIFIER = '_$HY.r';
-function createSerializer({
+const STATE = Symbol.for("dom-expressions.container-trace-state");
+const state = globalThis[STATE] || (globalThis[STATE] = {
+  materialized: new WeakMap(),
+  materializedValues: new WeakSet()
+});
+function setContainerTraceResolver(fn) {
+  state.resolveTrace = fn;
+}
+const TRACE = Symbol.for("dom-expressions.container-trace");
+function materialize(marker) {
+  let value = state.materialized.get(marker.$tr);
+  if (value === undefined) {
+    value = state.materializeTrace(marker);
+    state.materialized.set(marker.$tr, value);
+    if (value !== null && typeof value === "object") state.materializedValues.add(value);
+  }
+  return value;
+}
+function parseTrace(value, ctx) {
+  const trace = value[TRACE];
+  return {
+    a: trace.array ? 1 : 0,
+    i: ctx.parse(trace.subscribe())
+  };
+}
+const ContainerTracePlugin = {
+  tag: "dom-expressions/container-trace",
+  test(value) {
+    return value != null && typeof value === "object" && TRACE in value;
+  },
+  parse: {
+    sync() {
+      throw new Error("A reactive container can only be serialized by a streaming serializer.");
+    },
+    async async(value, ctx) {
+      const trace = value[TRACE];
+      return {
+        a: trace.array ? 1 : 0,
+        i: await ctx.parse(trace.subscribe())
+      };
+    },
+    stream: parseTrace
+  },
+  serialize(node, ctx) {
+    return "{$tr:" + ctx.serialize(node.i) + ",$ta:" + node.a + "}";
+  },
+  deserialize(node, ctx) {
+    const iterable = ctx.deserialize(node.i);
+    const marker = {
+      $tr: iterable,
+      $ta: node.a
+    };
+    return state.materializeTrace ? materialize(marker) : marker;
+  }
+};
+
+const DEFAULT_WEB_PLUGINS = Object.freeze([AbortSignalPlugin,
+CustomEventPlugin, DOMExceptionPlugin, EventPlugin,
+FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin,
+ContainerTracePlugin]);
+function resolveSerializerPlugins(customPlugins) {
+  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
+}
+Feature.RegExp;
+
+const DEFAULT_DISABLED_FEATURES = Feature.AggregateError | Feature.BigIntTypedArray;
+const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : Feature.ErrorPrototypeStack;
+const HYDRATION_GLOBAL = "_$HY.r";
+function createSerializer(options) {
+  return new Serializer({
+    ...options,
+    plugins: resolveSerializerPlugins(options.plugins),
+    disabledFeatures: (options.disabledFeatures === undefined ? DEFAULT_DISABLED_FEATURES : options.disabledFeatures) | serializeOnlyDisabledFeatures()
+  });
+}
+function createHydrationSerializer({
   onData,
   onDone,
   scopeId,
-  onError
+  onError,
+  plugins
 }) {
-  return new Serializer({
+  return createSerializer({
     scopeId,
-    plugins: [AbortSignalPlugin,
-    CustomEventPlugin, DOMExceptionPlugin, EventPlugin,
-    FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin],
-    globalIdentifier: GLOBAL_IDENTIFIER,
-    disabledFeatures: ES2017FLAG,
+    plugins,
+    globalIdentifier: HYDRATION_GLOBAL,
     onData,
     onDone,
     onError
   });
 }
 function getLocalHeaderScript(id) {
-  return getCrossReferenceHeader(id) + ';';
+  return getCrossReferenceHeader(id) + ";";
 }
 
+const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
+// PURE-annotated factory (same convention as solid's MockPromise): the brand
+const ResponseEnvelope = /* @__PURE__ */(() => {
+  class ResponseEnvelope {
+    constructor(response, value) {
+      this.response = response;
+      this.value = value;
+    }
+  }
+  ResponseEnvelope.prototype[ENVELOPE] = true;
+  return ResponseEnvelope;
+})();
+function isResponseEnvelope(value) {
+  return !!(value && typeof value === "object" && value[ENVELOPE]);
+}
+const HREF = Symbol.for("solid.Href");
+function isHref(value) {
+  return !!(value && (typeof value === "object" || typeof value === "function") && value[HREF]);
+}
+const SAFE_ERROR = Symbol.for("solid.SafeError");
+function markSafeError(error) {
+  if (error && (typeof error === "object" || typeof error === "function")) {
+    Object.defineProperty(error, SAFE_ERROR, {
+      value: true,
+      enumerable: false,
+      configurable: true
+    });
+  }
+  return error;
+}
+function isSafeError(value) {
+  return !!(value && (typeof value === "object" || typeof value === "function") && value[SAFE_ERROR]);
+}
+const REVALIDATE_HEADER = "X-Revalidate";
+function initWithRevalidate(init) {
+  const {
+    revalidate,
+    ...responseInit
+  } = init;
+  let headers;
+  if (responseInit.headers && responseInit.headers.getSetCookie) {
+    headers = new Headers();
+    responseInit.headers.forEach((value, key) => {
+      if (key !== "set-cookie") headers.append(key, value);
+    });
+    for (const cookie of responseInit.headers.getSetCookie()) {
+      headers.append("Set-Cookie", cookie);
+    }
+  } else {
+    headers = new Headers(responseInit.headers);
+  }
+  revalidate !== undefined && headers.set(REVALIDATE_HEADER, revalidate.toString());
+  return {
+    responseInit,
+    headers
+  };
+}
+function redirect(url, init = 302) {
+  if (typeof url !== "string" && !isHref(url)) {
+    throw new TypeError("redirect() expects a string URL or an Href-branded value (Symbol.for('solid.Href')).");
+  }
+  const {
+    responseInit,
+    headers
+  } = initWithRevalidate(typeof init === "number" ? {
+    status: init
+  } : init);
+  if (responseInit.status === undefined) {
+    responseInit.status = 302;
+  }
+  headers.set("Location", String(url));
+  return new Response(null, {
+    ...responseInit,
+    headers
+  });
+}
+function reload(init = {}) {
+  const {
+    responseInit,
+    headers
+  } = initWithRevalidate(init);
+  return new Response(null, {
+    ...responseInit,
+    headers
+  });
+}
+function respond(value, init = {}) {
+  const {
+    responseInit,
+    headers
+  } = initWithRevalidate(init);
+  headers.set("Content-Type", "application/json");
+  return new ResponseEnvelope(new Response(JSON.stringify(value), {
+    ...responseInit,
+    headers
+  }), value);
+}
+
+const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
+function getServerFunctionMetadata(fn) {
+  if (typeof fn !== "function") return undefined;
+  return fn[SERVER_FUNCTION_METADATA] || undefined;
+}
+function isServerFunction(fn) {
+  return typeof fn === "function" && !!fn[SERVER_FUNCTION_METADATA];
+}
+const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
+function getServerFunctionRPC() {
+  return globalThis[SERVER_FUNCTION_RPC];
+}
+
+function parseCookieHeader(header) {
+  const cookies = {};
+  if (!header) return cookies;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const name = decodeSafe(part.slice(0, eq).trim());
+    let value = part.slice(eq + 1).trim();
+    if (value.length > 1 && value[0] === '"' && value[value.length - 1] === '"') {
+      value = value.slice(1, -1);
+    }
+    cookies[name] = decodeSafe(value);
+  }
+  return cookies;
+}
+function decodeSafe(text) {
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+}
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  cookie += `; Path=${options.path === undefined ? "/" : options.path}`;
+  if (options.domain) cookie += `; Domain=${options.domain}`;
+  if (options.maxAge !== undefined) cookie += `; Max-Age=${Math.trunc(options.maxAge)}`;
+  if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options.httpOnly) cookie += "; HttpOnly";
+  if (options.secure) cookie += "; Secure";
+  if (options.sameSite) {
+    const sameSite = options.sameSite.toLowerCase();
+    cookie += `; SameSite=${sameSite === "none" ? "None" : sameSite === "strict" ? "Strict" : "Lax"}`;
+  }
+  return cookie;
+}
+const FLASH_COOKIE = "flash";
+const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+function hasFlashCookie(cookieHeader) {
+  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+}
+function clearFlashCookie() {
+  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
+}
+
+const ERROR_HEADER = "X-Server-Function-Error";
+const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
+
+const HEAD_ELIGIBLE_TAGS = new Set(["title", "meta", "link", "style", "script", "base"]);
+const HEAD_ATTR_NAME = /^[a-zA-Z_][a-zA-Z0-9_:.-]*$/;
+const RESOURCE_LINK_RELS = new Set(["preload", "modulepreload", "prefetch", "preconnect", "dns-prefetch", "stylesheet"]);
+const RESOURCE_QUALIFIERS = ["as", "crossorigin", "type", "media", "imagesrcset", "imagesizes"];
+const STYLESHEET_FETCH_META = new Set(["crossorigin", "integrity", "referrerpolicy", "fetchpriority"]);
+function evalHeadValue(v) {
+  return typeof v === "function" ? v() : v;
+}
+function evalHeadProps(props, presets) {
+  const out = {};
+  for (const name in props) out[name] = presets && name in presets ? presets[name] : evalHeadValue(props[name]);
+  return out;
+}
+function classifyHeadTag(desc) {
+  const tag = desc.tag;
+  if (tag === "link") {
+    const rel = evalHeadValue(desc.props && desc.props.rel);
+    return {
+      resource: RESOURCE_LINK_RELS.has(rel),
+      rel
+    };
+  }
+  if (tag === "style") return {
+    resource: !!(desc.props && "href" in desc.props)
+  };
+  if (tag === "script") return {
+    resource: !!(desc.props && "src" in desc.props)
+  };
+  return {
+    resource: false
+  };
+}
+function resourceIdentity(tag, props) {
+  let id = "res:" + tag + ":" + (props.rel || "") + ":" + (props.href || props.src || "");
+  for (let i = 0; i < RESOURCE_QUALIFIERS.length; i++) {
+    const q = RESOURCE_QUALIFIERS[i];
+    if (props[q] != null) id += ":" + q + "=" + props[q];
+  }
+  return id;
+}
+function replaceableIdentity(tag, props, key, unique) {
+  if (tag === "title") return "title";
+  if (tag === "base") return "base";
+  if (tag === "meta" && props.charset != null) return "charset";
+  if (key != null) return tag + ":key:" + key;
+  if (tag === "meta") {
+    for (const ns of ["name", "property", "http-equiv"]) if (props[ns] != null) return "meta:" + ns + ":" + props[ns] + (props.media != null ? ":media=" + props.media : "");
+    return unique;
+  }
+  if (tag === "link") {
+    const rel = props.rel || "";
+    if (rel === "icon" || rel === "apple-touch-icon") return "link:" + rel + (props.sizes != null ? ":sizes=" + props.sizes : "") + (props.type != null ? ":type=" + props.type : "");
+    return "link:" + rel + ":" + (props.href || "");
+  }
+  return unique;
+}
+function resolveHead(groups) {
+  const winners = new Map();
+  const sorted = groups.slice().sort((a, b) => a.seq - b.seq);
+  for (let i = 0; i < sorted.length; i++) {
+    const group = sorted[i];
+    const byIdentity = new Map();
+    for (let j = 0; j < group.tags.length; j++) {
+      const t = group.tags[j];
+      let list = byIdentity.get(t.identity);
+      if (!list) byIdentity.set(t.identity, list = []);
+      list.push(t);
+    }
+    for (const [identity, tags] of byIdentity) {
+      if (identity === "title") {
+        winners.set(identity, {
+          seq: group.seq,
+          tags: [tags[tags.length - 1]]
+        });
+      } else {
+        winners.set(identity, {
+          seq: group.seq,
+          tags
+        });
+      }
+    }
+  }
+  return winners;
+}
+
+function joinAssetPath(base, file) {
+  if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(file)) return file;
+  if (typeof base !== "string" || !base) base = "/";
+  if (base[base.length - 1] !== "/") base += "/";
+  return base + (file[0] === "/" ? file.slice(1) : file);
+}
+function resolveAssets(moduleUrl, manifest) {
+  if (!manifest) return null;
+  const base = manifest._base;
+  const entry = manifest[moduleUrl];
+  if (!entry) return null;
+  const css = [];
+  const js = [];
+  const visited = new Set();
+  const walk = key => {
+    if (visited.has(key)) return;
+    visited.add(key);
+    const e = manifest[key];
+    if (!e) return;
+    js.push(joinAssetPath(base, e.file));
+    if (e.css) for (let i = 0; i < e.css.length; i++) css.push(joinAssetPath(base, e.css[i]));
+    if (e.imports) for (let i = 0; i < e.imports.length; i++) walk(e.imports[i]);
+  };
+  walk(moduleUrl);
+  return {
+    js,
+    css
+  };
+}
+function registerEntryAssets(manifest) {
+  if (!manifest || typeof manifest === "function" || typeof manifest.resolve === "function") return;
+  const ctx = sharedConfig.context;
+  if (!ctx?.registerAsset) return;
+  for (const key in manifest) {
+    if (manifest[key].isEntry) {
+      const assets = resolveAssets(key, manifest);
+      if (assets) {
+        for (let i = 0; i < assets.css.length; i++) ctx.registerAsset("style", assets.css[i]);
+      }
+      return;
+    }
+  }
+}
+function createAssetTracking() {
+  const boundaryModules = new Map();
+  const boundaryStyles = new Map();
+  const emittedAssets = new Set();
+  const inlineStyles = new Map();
+  let currentBoundaryId = null;
+  return {
+    boundaryModules,
+    boundaryStyles,
+    emittedAssets,
+    inlineStyles,
+    registerInlineStyle(desc) {
+      let entry = inlineStyles.get(desc.id);
+      if (!entry) {
+        entry = {
+          id: desc.id,
+          content: desc.content || "",
+          attrs: desc.attrs,
+          emitted: false
+        };
+        inlineStyles.set(desc.id, entry);
+      }
+      if (currentBoundaryId) {
+        let styles = boundaryStyles.get(currentBoundaryId);
+        if (!styles) {
+          styles = new Set();
+          boundaryStyles.set(currentBoundaryId, styles);
+        }
+        styles.add(entry);
+      }
+      return entry;
+    },
+    get currentBoundaryId() {
+      return currentBoundaryId;
+    },
+    set currentBoundaryId(v) {
+      currentBoundaryId = v;
+    },
+    registerModule(key, entryUrl) {
+      const id = currentBoundaryId || "";
+      let map = boundaryModules.get(id);
+      if (!map) {
+        map = {};
+        boundaryModules.set(id, map);
+      }
+      map[key] = entryUrl;
+    },
+    getBoundaryModules(id) {
+      return boundaryModules.get(id) || null;
+    },
+    getBoundaryStyles(id) {
+      return boundaryStyles.get(id) || null;
+    }
+  };
+}
+function warnUnresolvedModuleAssets(moduleUrl, warned) {
+  if (warned.has(moduleUrl)) return;
+  warned.add(moduleUrl);
+  console.error(`Asset manifest returned no client assets for module "${moduleUrl}". ` + "If this module is a server-rendered lazy() component, its entry will be missing from " + "the serialized hydration asset map, the client will be unable to preload it, and " + "hydration will fail with 'lazy() module \"…\" was not preloaded before hydration'. " + "This means the integration's asset resolver (dev manifest bridge or build client " + "manifest) failed to answer for this module — check the integration's server logs, " + "restart the dev server, or verify the module is included in the client build.");
+}
+function guardResolvedAssets(moduleUrl, result, warned) {
+  if (result && typeof result.then === "function") {
+    return result.then(assets => {
+      if (!assets || !assets.js || !assets.js.length) warnUnresolvedModuleAssets(moduleUrl, warned);
+      return assets;
+    });
+  }
+  if (!result || !result.js || !result.js.length) warnUnresolvedModuleAssets(moduleUrl, warned);
+  return result;
+}
+function applyAssetTracking(context, tracking, manifest, noScripts) {
+  const warned = new Set();
+  const guard = noScripts ? resolve => resolve : resolve => moduleUrl => guardResolvedAssets(moduleUrl, resolve(moduleUrl), warned);
+  Object.defineProperty(context, "_currentBoundaryId", {
+    get() {
+      return tracking.currentBoundaryId;
+    },
+    set(v) {
+      tracking.currentBoundaryId = v;
+    },
+    configurable: true,
+    enumerable: true
+  });
+  context.registerModule = tracking.registerModule;
+  context.getBoundaryModules = tracking.getBoundaryModules;
+  if (typeof manifest === "function") {
+    context.resolveAssets = guard(manifest);
+  } else if (manifest && typeof manifest.resolve === "function") {
+    context.resolveAssets = guard(key => manifest.resolve(key));
+    if (typeof manifest.resolveSync === "function") {
+      context.resolveAssetsSync = key => manifest.resolveSync(key);
+    }
+  } else if (manifest) {
+    const resolve = moduleUrl => resolveAssets(moduleUrl, manifest);
+    context.resolveAssets = guard(resolve);
+    context.resolveAssetsSync = resolve;
+  }
+}
+function isCssUrl(url) {
+  const q = url.search(/[?#]/);
+  return (q === -1 ? url : url.slice(0, q)).endsWith(".css");
+}
+function createHeadRegistry() {
+  return {
+    pending: [],
+    committed: [],
+    seq: 0,
+    uniq: 0,
+    resources: new Set(),
+    eagerHtml: "",
+    flushed: null,
+    shellFlushed: false,
+    parkedResources: []
+  };
+}
+function registerHeadTags(registry, context, tracking, emitResource, nonce, tags) {
+  const boundary = context._currentBoundaryId || "";
+  if (typeof tags === "function") {
+    registry.pending.push({
+      boundary,
+      list: tags,
+      resource: (desc, rel) => emitHeadResource(registry, context, tracking, emitResource, nonce, desc, rel)
+    });
+    return;
+  }
+  if (!Array.isArray(tags)) tags = [tags];
+  const probe = sharedConfig.context && sharedConfig.context._loadingPhase;
+  let replaceable = null;
+  for (let i = 0; i < tags.length; i++) {
+    const desc = tags[i];
+    if (!desc || !HEAD_ELIGIBLE_TAGS.has(desc.tag)) {
+      continue;
+    }
+    const cls = classifyHeadTag(desc);
+    if (probe && !cls.resource) {
+      try {
+        evalHeadProps(desc.props || {}, cls.rel !== undefined ? {
+          rel: cls.rel
+        } : undefined);
+        evalHeadValue(desc.key);
+      } catch (err) {
+        if (ssrHandleError(err)) throw err;
+      }
+    }
+    if (cls.resource) {
+      emitHeadResource(registry, context, tracking, emitResource, nonce, desc, cls.rel);
+    } else {
+      (replaceable || (replaceable = [])).push(cls.rel !== undefined ? {
+        tag: desc.tag,
+        props: desc.props,
+        key: desc.key,
+        rel: cls.rel
+      } : desc);
+    }
+  }
+  if (replaceable) registry.pending.push({
+    boundary,
+    tags: replaceable
+  });
+}
+function headShellReady(registry, block) {
+  let ready = true;
+  const pends = err => {
+    const source = ssrHandleError(err, true);
+    if (!source) return false;
+    block(source);
+    ready = false;
+    return true;
+  };
+  const parked = registry.parkedResources;
+  for (let i = parked.length - 1; i >= 0; i--) {
+    const {
+      desc,
+      rel,
+      emit
+    } = parked[i];
+    try {
+      evalHeadProps(desc.props || {}, rel !== undefined ? {
+        rel
+      } : undefined);
+    } catch (err) {
+      if (pends(err)) continue;
+      parked.splice(i, 1);
+      continue;
+    }
+    parked.splice(i, 1);
+    emit();
+  }
+  for (let i = 0; i < registry.pending.length; i++) {
+    const reg = registry.pending[i];
+    if (reg.boundary !== "" || reg.list) continue;
+    for (let j = 0; j < reg.tags.length; j++) {
+      const desc = reg.tags[j];
+      try {
+        evalHeadProps(desc.props || {}, desc.rel !== undefined ? {
+          rel: desc.rel
+        } : undefined);
+        evalHeadValue(desc.key);
+      } catch (err) {
+        pends(err);
+      }
+    }
+  }
+  return ready;
+}
+function emitHeadResource(registry, context, tracking, emitResource, nonce, desc, rel) {
+  let props;
+  try {
+    props = evalHeadProps(desc.props || {}, rel !== undefined ? {
+      rel
+    } : undefined);
+  } catch (err) {
+    const loadingPhase = sharedConfig.context && sharedConfig.context._loadingPhase;
+    if (loadingPhase && ssrHandleError(err)) throw err;
+    if (!loadingPhase && !context._currentBoundaryId && !registry.shellFlushed && typeof context.block === "function" && ssrHandleError(err, true)) {
+      registry.parkedResources.push({
+        desc,
+        rel,
+        emit: () => emitHeadResource(registry, context, tracking, emitResource, nonce, desc, rel)
+      });
+      return;
+    }
+    return;
+  }
+  const identity = resourceIdentity(desc.tag, props);
+  if (registry.resources.has(identity)) return;
+  registry.resources.add(identity);
+  if (desc.tag === "link" && (rel === "stylesheet" || rel === "modulepreload")) {
+    let plain = true;
+    let gateable = rel === "stylesheet";
+    for (const name in props) {
+      if (name === "rel" || name === "href") continue;
+      plain = false;
+      if (!STYLESHEET_FETCH_META.has(name)) gateable = false;
+    }
+    if (plain && props.href != null) {
+      const isCss = isCssUrl(props.href);
+      if (rel === "stylesheet" ? isCss : !isCss) {
+        context.registerAsset(rel === "stylesheet" ? "style" : "module", props.href);
+        return;
+      }
+    }
+    if (gateable && props.href != null) {
+      const attrHtml = renderHeadAttrHtml(props);
+      const entry = {
+        href: props.href,
+        attrHtml,
+        attrs: headAttrRecord(props)
+      };
+      if (tracking.currentBoundaryId) {
+        let styles = tracking.boundaryStyles.get(tracking.currentBoundaryId);
+        if (!styles) tracking.boundaryStyles.set(tracking.currentBoundaryId, styles = new Set());
+        styles.add(entry);
+      }
+      const markup = `<link${attrHtml}>`;
+      if (emitResource) emitResource(markup, entry);else {
+        registry.eagerHtml += markup;
+        entry.emitted = true;
+      }
+      return;
+    }
+  }
+  const url = props.href || props.src;
+  if (url != null && tracking.emittedAssets.has(url)) return;
+  const markup = renderHeadTagMarkup(desc.tag, props, null, nonce);
+  if (emitResource) emitResource(markup);else registry.eagerHtml += markup;
+}
+function commitHeadBoundary(registry, boundary, isPendingFragment) {
+  const keep = [];
+  const groups = [];
+  for (let i = 0; i < registry.pending.length; i++) {
+    const reg = registry.pending[i];
+    const mine = boundary === "" ? !(isPendingFragment && reg.boundary !== "" && isPendingFragment(reg.boundary)) : reg.boundary === boundary;
+    if (!mine) {
+      keep.push(reg);
+      continue;
+    }
+    let descs = reg.tags;
+    if (reg.list) {
+      let resolved;
+      try {
+        resolved = reg.list();
+      } catch (err) {
+        continue;
+      }
+      if (!Array.isArray(resolved)) resolved = [resolved];
+      descs = [];
+      for (let j = 0; j < resolved.length; j++) {
+        const desc = resolved[j];
+        if (!desc || !HEAD_ELIGIBLE_TAGS.has(desc.tag)) {
+          continue;
+        }
+        const cls = classifyHeadTag(desc);
+        if (cls.resource) {
+          reg.resource(desc, cls.rel);
+        } else {
+          descs.push(cls.rel !== undefined ? {
+            tag: desc.tag,
+            props: desc.props,
+            key: desc.key,
+            rel: cls.rel
+          } : desc);
+        }
+      }
+    }
+    const tags = [];
+    for (let j = 0; j < descs.length; j++) {
+      const desc = descs[j];
+      let props, key;
+      try {
+        props = evalHeadProps(desc.props || {}, desc.rel !== undefined ? {
+          rel: desc.rel
+        } : undefined);
+        key = evalHeadValue(desc.key);
+      } catch (err) {
+        continue;
+      }
+      const identity = replaceableIdentity(desc.tag, props, key, "u:" + registry.uniq++);
+      if ((identity === "base" || identity === "charset") && registry.shellFlushed) {
+        continue;
+      }
+      tags.push({
+        tag: desc.tag,
+        props,
+        identity
+      });
+    }
+    if (tags.length) groups.push({
+      seq: registry.seq++,
+      tags
+    });
+  }
+  registry.pending = keep;
+  for (let i = 0; i < groups.length; i++) registry.committed.push(groups[i]);
+  return groups;
+}
+function adoptHeadBoundary(registry, childKey, parentKey) {
+  for (let i = 0; i < registry.pending.length; i++) {
+    if (registry.pending[i].boundary === childKey) registry.pending[i].boundary = parentKey;
+  }
+}
+function dropHeadBoundary(registry, boundary) {
+  registry.pending = registry.pending.filter(reg => reg.boundary !== boundary);
+}
+function headGroupSignature(winner) {
+  let sig = "" + winner.seq;
+  for (let i = 0; i < winner.tags.length; i++) {
+    const t = winner.tags[i];
+    sig += "|" + t.tag + JSON.stringify(t.props);
+  }
+  return sig;
+}
+function renderShellHead(registry, nonce, isPendingFragment) {
+  commitHeadBoundary(registry, "", isPendingFragment);
+  registry.shellFlushed = true;
+  const winners = resolveHead(registry.committed);
+  registry.flushed = new Map();
+  let prelude = "";
+  let links = "";
+  let metas = "";
+  let others = "";
+  let scripts = "";
+  for (const [identity, winner] of winners) {
+    registry.flushed.set(identity, headGroupSignature(winner));
+    for (let i = 0; i < winner.tags.length; i++) {
+      const t = winner.tags[i];
+      const markup = renderHeadTagMarkup(t.tag, t.props, identity, nonce);
+      if (identity === "charset" || identity === "base") prelude += markup;else if (t.tag === "link" || t.tag === "style") links += markup;else if (t.tag === "meta") metas += markup;else if (t.tag === "script") scripts += markup;else others += markup;
+    }
+  }
+  return {
+    prelude,
+    html: registry.eagerHtml + links + metas + others + scripts
+  };
+}
+function flushHeadFragment(registry, boundary) {
+  const groups = commitHeadBoundary(registry, boundary);
+  if (!groups.length) return null;
+  const winners = resolveHead(registry.committed);
+  const affected = new Set();
+  for (let i = 0; i < groups.length; i++) for (let j = 0; j < groups[i].tags.length; j++) affected.add(groups[i].tags[j].identity);
+  const ops = [];
+  for (const identity of affected) {
+    const winner = winners.get(identity);
+    const sig = headGroupSignature(winner);
+    if (registry.flushed.get(identity) === sig) continue;
+    const existed = registry.flushed.has(identity);
+    registry.flushed.set(identity, sig);
+    if (identity === "title") {
+      const children = winner.tags[0].props.children;
+      ops.push(["t", children == null ? "" : String(children)]);
+      continue;
+    }
+    if (existed) ops.push(["r", identity]);
+    for (let i = 0; i < winner.tags.length; i++) {
+      const t = winner.tags[i];
+      const attrs = {};
+      for (const name in t.props) {
+        if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
+        if (!HEAD_ATTR_NAME.test(name)) {
+          continue;
+        }
+        const v = t.props[name];
+        if (v == null || v === false) continue;
+        attrs[name] = v === true ? "" : String(v);
+      }
+      const children = t.props.children;
+      ops.push(["a", identity, t.tag, attrs, children == null ? null : String(children)]);
+    }
+  }
+  return ops.length ? ops : null;
+}
+function renderHeadAttrHtml(props) {
+  let attrs = "";
+  for (const name in props) {
+    if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
+    if (!HEAD_ATTR_NAME.test(name)) {
+      continue;
+    }
+    const v = props[name];
+    if (v == null || v === false) continue;
+    attrs += v === true ? ` ${name}` : ` ${name}="${escape(String(v), true)}"`;
+  }
+  return attrs;
+}
+function headAttrRecord(props, skipRelHref) {
+  let attrs = null;
+  for (const name in props) {
+    if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
+    if ((name === "rel" || name === "href")) continue;
+    if (!HEAD_ATTR_NAME.test(name)) continue;
+    const v = props[name];
+    if (v == null || v === false) continue;
+    (attrs || (attrs = {}))[name] = v === true ? "" : String(v);
+  }
+  return attrs;
+}
+function renderHeadTagMarkup(tag, props, identity, nonce) {
+  let attrs = renderHeadAttrHtml(props);
+  if (identity != null) attrs += ` data-dh="${escape(identity, true)}"`;
+  if (nonce && (tag === "script" || tag === "style")) attrs += ` nonce="${nonce}"`;
+  if (tag === "meta" || tag === "link" || tag === "base") return `<${tag}${attrs}>`;
+  let body = props.children == null ? "" : String(props.children);
+  if (tag === "script") body = body.replace(/<\/(script)/gi, "<\\/$1");else if (tag === "style") body = escapeStyleContent(body);else body = escape(body);
+  return `<${tag}${attrs}>${body}</${tag}>`;
+}
+function useHead(tags) {
+  const ctx = sharedConfig.context;
+  if (!ctx || !ctx.registerHeadTags) {
+    return;
+  }
+  ctx.registerHeadTags(tags);
+}
 const VOID_ELEMENTS = /^(?:area|base|br|col|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)$/i;
-const REPLACE_SCRIPT = `function $df(e,n,o,t){if(n=document.getElementById(e),o=document.getElementById("pl-"+e)){for(;o&&8!==o.nodeType&&o.nodeValue!=="pl-"+e;)t=o.nextSibling,o.remove(),o=t;_$HY.done?o.remove():o.replaceWith(n.content)}n.remove(),_$HY.fe(e)}`;
+const REPLACE_SCRIPT = `function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById("pl-"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!=="pl-"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById("pl-"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue==="pl-"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}`;
+const HEAD_SCRIPT = `function $dha(o,i,e,n){for(i=0;i<o.length;i++)e=o[i],"t"==e[0]?((n=document.querySelector("title"))||(n=document.createElement("title"),document.head.appendChild(n)),n.textContent=e[1],n.setAttribute("data-dh","title")):"r"==e[0]?$dhr(e[1]):(n=document.createElement(e[2]),Object.keys(e[3]).forEach(function(a){n.setAttribute(a,e[3][a])}),null!=e[4]&&(n.textContent=e[4]),n.setAttribute("data-dh",e[1]),document.head.appendChild(n))}function $dhr(v,l,i){for(l=document.head.querySelectorAll("[data-dh]"),i=0;i<l.length;i++)l[i].getAttribute("data-dh")==v&&l[i].remove()}function $dh(o){_$HY.h?_$HY.h(o):$dha(o)}`;
 function renderToString(code, options = {}) {
   const {
     renderId = "",
     nonce,
-    noScripts
+    noScripts,
+    manifest,
+    onHead
   } = options;
   let scripts = "";
-  const serializer = createSerializer({
+  const serializer = createHydrationSerializer({
     scopeId: renderId,
+    plugins: options.plugins,
     onData(script) {
       if (noScripts) return;
       if (!scripts) {
@@ -67,27 +923,52 @@ function renderToString(code, options = {}) {
     },
     onError: options.onError
   });
+  const tracking = createAssetTracking();
+  const headRegistry = createHeadRegistry();
   sharedConfig.context = {
-    assets: [],
     nonce,
     escape: escape,
     resolve: resolveSSRNode,
     ssr: ssr,
+    registerHeadTags(tags) {
+      registerHeadTags(headRegistry, sharedConfig.context, tracking, null, nonce, tags);
+    },
     serialize(id, p) {
-      !sharedConfig.context.noHydrate && serializer.write(id, p);
+      if (sharedConfig.context.noHydrate) return;
+      if (p != null && typeof p === "object" && (typeof p.then === "function" || typeof p[Symbol.asyncIterator] === "function")) {
+        throw new Error("Cannot serialize async value in renderToString (id: " + id + "). " + "Use renderToStream for async data.");
+      }
+      serializer.write(id, p);
+    },
+    registerAsset(type, value) {
+      if (type === "inline-style") {
+        tracking.registerInlineStyle(value);
+        return;
+      }
+      if (tracking.currentBoundaryId && type === "style") {
+        let styles = tracking.boundaryStyles.get(tracking.currentBoundaryId);
+        if (!styles) {
+          styles = new Set();
+          tracking.boundaryStyles.set(tracking.currentBoundaryId, styles);
+        }
+        styles.add(value);
+      }
+      tracking.emittedAssets.add(value);
     }
   };
+  applyAssetTracking(sharedConfig.context, tracking, manifest, noScripts);
+  registerEntryAssets(manifest);
   let html = createRoot(d => {
     setTimeout(d);
     return resolveSSRSync(escape(code()));
   }, {
     id: renderId
   });
+  serializeFragmentAssets("", tracking.boundaryModules, sharedConfig.context, renderId);
   sharedConfig.context.noHydrate = true;
   serializer.close();
-  html = injectAssets(sharedConfig.context.assets, html);
-  if (scripts.length) html = injectScripts(html, scripts, options.nonce);
-  return html;
+  const head = renderShellHead(headRegistry, nonce, null);
+  return assembleDocument(html, tracking.emittedAssets, tracking.inlineStyles, scripts.length ? scripts : "", nonce, head, onHead);
 }
 function renderToStream(code, options = {}) {
   let {
@@ -95,18 +976,64 @@ function renderToStream(code, options = {}) {
     onCompleteShell,
     onCompleteAll,
     renderId = "",
-    noScripts
+    noScripts,
+    manifest,
+    onHead
   } = options;
   let dispose;
-  const blockingPromises = [];
+  let dead = false;
+  const abandon = () => {
+    if (dead) return;
+    dead = true;
+    completed = true;
+    buffer = {
+      write() {}
+    };
+    writable = {
+      end() {}
+    };
+    if (dispose) {
+      const d = dispose;
+      dispose = () => {};
+      d();
+    }
+  };
+  const failRender = err => {
+    try {
+      options.onError ? options.onError(err) : console.error(err);
+    } catch (_) {}
+    abandon();
+  };
+  const guardSink = w => ({
+    write(payload) {
+      if (dead) return;
+      try {
+        w.write(payload);
+      } catch (_) {
+        abandon();
+      }
+    },
+    end() {
+      if (dead) return;
+      try {
+        w.end();
+      } catch (_) {
+        abandon();
+      }
+    }
+  });
+  const blockingPromises = new Set();
+  let headerEmitted = false;
   const pushTask = task => {
     if (noScripts) return;
-    if (!tasks && !firstFlushed) {
-      tasks = getLocalHeaderScript(renderId);
+    if (!headerEmitted) {
+      headerEmitted = true;
+      tasks += getLocalHeaderScript(renderId);
     }
     tasks += task + ";";
     if (!timer && firstFlushed) {
-      timer = setTimeout(writeTasks);
+      timer = true;
+      queue(() => queue(writeTasks));
     }
   };
   const onDone = () => {
@@ -121,15 +1048,72 @@ function renderToStream(code, options = {}) {
     completed = true;
     if (firstFlushed) dispose();
   };
-  const serializer = createSerializer({
+  const sink = {
+    data(payload) {
+      pushTask(payload);
+    },
+    fragment(key, value, meta) {
+      const deferActivation = !!meta.revealGroup;
+      const styles = meta.styles;
+      for (let i = 0; i < styles.inline.length; i++) {
+        buffer.write(renderInlineStyle(styles.inline[i], nonce));
+      }
+      if (styles.links.length) {
+        emitTask(`$dfs("${key}",${styles.links.length},${deferActivation ? 1 : 0})`);
+        writeTasks();
+        for (const entry of styles.links) {
+          buffer.write(typeof entry === "string" ? `<link rel="stylesheet" href="${entry}" onload="$dfc('${key}')" onerror="$dfc('${key}')">` : `<link${entry.attrHtml} onload="$dfc('${key}')" onerror="$dfc('${key}')">`);
+        }
+        buffer.write(`<template id="${key}">${value}</template>`);
+      } else {
+        buffer.write(`<template id="${key}">${value}</template>`);
+        if (!deferActivation) {
+          emitTask(`$df("${key}")`);
+        }
+      }
+    },
+    reveal(keys, meta) {
+      emitTask(`${meta.fallback ? "$dflj" : "$dfj"}(${JSON.stringify(keys)})`);
+    },
+    asset(type, value) {
+      if (type === "module") {
+        buffer.write(`<link rel="modulepreload" href="${value}">`);
+      } else if (type === "inline-style") {
+        buffer.write(renderInlineStyle(value, nonce));
+      } else if (type === "head-tag") {
+        buffer.write(value);
+      }
+    },
+    shell(shellHtml, meta) {
+      buffer.write(assembleDocument(shellHtml, meta.preloads, meta.inlineStyles, meta.tasks.length ? meta.tasks : "", nonce, meta.head, onHead));
+    },
+    ...options.sink
+  };
+  const serializer = (options.serializer || createHydrationSerializer)({
     scopeId: options.renderId,
-    onData: pushTask,
+    plugins: options.plugins,
+    onData: payload => sink.data(payload),
     onDone,
     onError: options.onError
   });
+  let rootAssetsSerialized = false;
+  const serializeRootAssets = () => {
+    if (rootAssetsSerialized) return;
+    rootAssetsSerialized = true;
+    serializeFragmentAssets("", tracking.boundaryModules, context, renderId);
+  };
+  let holds = 0;
   const flushEnd = () => {
-    if (!registry.size) {
-      queue(() => queue(() => serializer.flush()));
+    if (!registry.size && !holds) {
+      serializeRootAssets();
+      queue(() => queue(() => {
+        if (context.live.end) {
+          const end = context.live.end;
+          context.live.end = null;
+          end();
+        }
+        serializer.flush();
+      }));
     }
   };
   const registry = new Map();
@@ -138,7 +1122,6 @@ function renderToStream(code, options = {}) {
       buffer.write(`<script${nonce ? ` nonce="${nonce}"` : ""}>${tasks}</script>`);
       tasks = "";
     }
-    timer && clearTimeout(timer);
     timer = null;
   };
   let context;
@@ -149,18 +1132,94 @@ function renderToStream(code, options = {}) {
   let completed = false;
   let shellCompleted = false;
   let scriptFlushed = false;
+  let headStyles;
+  const revealGroups = new Map();
   let timer = null;
+  const emitTask = task => {
+    pushTask(`${task}${!scriptFlushed ? ";" + REPLACE_SCRIPT : ""}`);
+    scriptFlushed = true;
+  };
+  function resolveRevealKeys(groupOrKeys, release, consume) {
+    if (Array.isArray(groupOrKeys)) return groupOrKeys.slice();
+    let group = revealGroups.get(groupOrKeys);
+    if (!group) {
+      if (!release) return;
+      group = {
+        order: [],
+        keys: new Set(),
+        released: true
+      };
+      revealGroups.set(groupOrKeys, group);
+    } else if (release) group.released = true;
+    if (!group.order.length) return;
+    const keys = group.order.slice();
+    if (consume) revealGroups.delete(groupOrKeys);
+    return keys;
+  }
+  let rootHoles = null;
+  let nextHoleId = 0;
   let buffer = {
     write(payload) {
       tmp += payload;
     }
   };
+  const tracking = createAssetTracking();
+  const headRegistry = createHeadRegistry();
+  let headScriptFlushed = false;
+  const emitHeadOps = (key, ops) => {
+    const payload = JSON.stringify(ops).replace(/</g, "\\u003C");
+    emitTask(`${!headScriptFlushed ? HEAD_SCRIPT : ""}(_$HY.hp=_$HY.hp||{})[${JSON.stringify(key)}]=${payload}`);
+    headScriptFlushed = true;
+  };
   sharedConfig.context = context = {
     async: true,
-    assets: [],
     nonce,
+    live: {},
+    registerHeadTags(tags) {
+      registerHeadTags(headRegistry, context, tracking,
+      (markup, gateEntry) => {
+        if (!firstFlushed) {
+          headRegistry.eagerHtml += markup;
+          if (gateEntry) gateEntry.emitted = true;
+        } else if (!gateEntry || !tracking.currentBoundaryId) {
+          sink.asset("head-tag", markup);
+        }
+      }, nonce, tags);
+    },
+    registerAsset(type, value) {
+      if (type === "inline-style") {
+        const entry = tracking.registerInlineStyle(value);
+        if (firstFlushed && !tracking.currentBoundaryId && !entry.emitted) {
+          entry.emitted = true;
+          sink.asset("inline-style", entry);
+        }
+        return;
+      }
+      if (tracking.currentBoundaryId && type === "style") {
+        let styles = tracking.boundaryStyles.get(tracking.currentBoundaryId);
+        if (!styles) {
+          styles = new Set();
+          tracking.boundaryStyles.set(tracking.currentBoundaryId, styles);
+        }
+        styles.add(value);
+      }
+      if (!tracking.emittedAssets.has(value)) {
+        tracking.emittedAssets.add(value);
+        if (firstFlushed) sink.asset(type, value);
+      }
+    },
     block(p) {
-      if (!firstFlushed) blockingPromises.push(p);
+      if (!firstFlushed) blockingPromises.add(p);
+    },
+    hold() {
+      holds++;
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        holds--;
+        if (!holds) queue(flushEnd);
+      };
     },
     replace(id, payloadFn) {
       if (firstFlushed) return;
@@ -170,21 +1229,36 @@ function renderToStream(code, options = {}) {
       const last = html.indexOf(`<!--!$/${id}-->`, first + placeholder.length);
       html = html.slice(0, first) + resolveSSRSync(escape(payloadFn())) + html.slice(last + placeholder.length + 1);
     },
-    serialize(id, p, wait) {
-      const serverOnly = sharedConfig.context.noHydrate;
-      if (!firstFlushed && wait && typeof p === "object" && "then" in p) {
-        blockingPromises.push(p);
-        !serverOnly && p.then(d => {
-          serializer.write(id, d);
-        }).catch(e => {
-          serializer.write(id, e);
-        });
-      } else if (!serverOnly) serializer.write(id, p);
+    serialize(id, p, deferStream) {
+      if (sharedConfig.context.noHydrate) return;
+      if (!firstFlushed && deferStream && typeof p === "object" && "then" in p) {
+        blockingPromises.add(p);
+        p.then(d => serializer.write(id, d)).catch(e => serializer.write(id, e));
+      } else serializer.write(id, p);
     },
     escape: escape,
     resolve: resolveSSRNode,
     ssr: ssr,
-    registerFragment(key) {
+    registerFragment(key, options) {
+      const revealGroup = options && options.revealGroup;
+      if (revealGroup) {
+        let group = revealGroups.get(revealGroup);
+        if (!group) {
+          group = {
+            order: [],
+            keys: new Set(),
+            released: false
+          };
+          revealGroups.set(revealGroup, group);
+        }
+        if (!group.keys.has(key)) {
+          group.keys.add(key);
+          group.order.push(key);
+        }
+        if (group.released) {
+          throw new Error("registerFragment() for reveal group '" + revealGroup + "' was called after revealFragments(). Ensure template payload is emitted before grouped reveal.");
+        }
+      }
       if (!registry.has(key)) {
         let resolve, reject;
         const p = new Promise((r, rej) => (resolve = r, reject = rej));
@@ -194,7 +1268,7 @@ function renderToStream(code, options = {}) {
             queue(flushEnd);
           }))
         });
-        serializer.write(key, p);
+        serializer.write(key + "_fr", p);
       }
       return (value, error) => {
         if (registry.has(key)) {
@@ -210,37 +1284,121 @@ function renderToStream(code, options = {}) {
             const parent = registry.get(parentKey);
             parent.children ||= {};
             parent.children[key] = value !== undefined ? value : "";
+            serializeFragmentAssets(key, tracking.boundaryModules, context);
+            propagateBoundaryStyles(key, parentKey, tracking);
+            adoptHeadBoundary(headRegistry, key, parentKey);
             item.resolve();
             return;
           }
           if (!completed) {
+            if (error) dropHeadBoundary(headRegistry, key);
             if (!firstFlushed) {
               queue(() => html = replacePlaceholder(html, key, value !== undefined ? value : ""));
+              serializeFragmentAssets(key, tracking.boundaryModules, context);
               item.resolve(error);
             } else {
-              buffer.write(`<template id="${key}">${value !== undefined ? value : " "}</template>`);
-              pushTask(`$df("${key}")${!scriptFlushed ? ";" + REPLACE_SCRIPT : ""}`);
+              serializeFragmentAssets(key, tracking.boundaryModules, context);
+              const styles = collectStreamStyles(key, tracking, headStyles);
+              const headOps = error ? null : flushHeadFragment(headRegistry, key);
+              if (headOps) emitHeadOps(key, headOps);
+              sink.fragment(key, value !== undefined ? value : " ", {
+                styles,
+                revealGroup,
+                error
+              });
               item.resolve(error);
-              scriptFlushed = true;
             }
           }
         }
         return firstFlushed;
       };
+    },
+    revealFragments(groupOrKeys) {
+      const keys = resolveRevealKeys(groupOrKeys, true, true);
+      if (!keys) return;
+      sink.reveal(keys, {
+        fallback: false
+      });
+    },
+    revealFallbacks(groupOrKeys) {
+      const keys = resolveRevealKeys(groupOrKeys, false, false);
+      if (!keys) return;
+      sink.reveal(keys, {
+        fallback: true
+      });
     }
   };
+  applyAssetTracking(context, tracking, manifest, noScripts);
+  context.failRender = failRender;
+  registerEntryAssets(manifest);
   let html = createRoot(d => {
     dispose = d;
-    return resolveSSRSync(escape(code()));
+    const res = resolveSSRNode(escape(code()));
+    if (!res.h.length) return res.t[0];
+    rootHoles = [];
+    let out = res.t[0];
+    for (let i = 0; i < res.h.length; i++) {
+      const id = nextHoleId++;
+      rootHoles.push({
+        id,
+        fn: res.h[i]
+      });
+      out += `<!--rh${id}-->` + res.t[i + 1];
+    }
+    for (const p of res.p) blockingPromises.add(p);
+    return out;
   }, {
     id: renderId
   });
+  function resolveRootHoles() {
+    if (!rootHoles) return true;
+    const pending = [];
+    for (const {
+      id,
+      fn
+    } of rootHoles) {
+      const marker = `<!--rh${id}-->`;
+      const res = resolveSSRNode(fn);
+      if (!res.h.length) {
+        html = html.replace(marker, res.t[0]);
+      } else {
+        let out = res.t[0];
+        for (let j = 0; j < res.h.length; j++) {
+          const newId = nextHoleId++;
+          pending.push({
+            id: newId,
+            fn: res.h[j]
+          });
+          out += `<!--rh${newId}-->` + res.t[j + 1];
+        }
+        html = html.replace(marker, out);
+        for (const p of res.p) blockingPromises.add(p);
+      }
+    }
+    if (pending.length) {
+      rootHoles = pending;
+      return false;
+    }
+    rootHoles = null;
+    return true;
+  }
   function doShell() {
     if (shellCompleted) return;
     sharedConfig.context = context;
-    html = injectAssets(context.assets, html);
-    if (tasks.length) html = injectScripts(html, tasks, nonce);
-    buffer.write(html);
+    if (!resolveRootHoles()) return;
+    if (!headShellReady(headRegistry, p => blockingPromises.add(p))) return;
+    headStyles = new Set();
+    for (const url of tracking.emittedAssets) {
+      if (isCssUrl(url)) headStyles.add(url);
+    }
+    serializeRootAssets();
+    const head = renderShellHead(headRegistry, nonce, k => registry.has(k));
+    sink.shell(html, {
+      preloads: tracking.emittedAssets,
+      inlineStyles: tracking.inlineStyles,
+      tasks,
+      head
+    });
     tasks = "";
     onCompleteShell && onCompleteShell({
       write(v) {
@@ -249,53 +1407,72 @@ function renderToStream(code, options = {}) {
     });
     shellCompleted = true;
   }
-  return {
-    then(fn) {
-      function complete() {
-        dispose();
-        fn(tmp);
-      }
-      if (onCompleteAll) {
-        let ogComplete = onCompleteAll;
-        onCompleteAll = options => {
-          ogComplete(options);
-          complete();
-        };
-      } else onCompleteAll = complete;
-      queue(flushEnd);
-    },
-    pipe(w) {
+  const MIN_DRAIN_TURNS = 8;
+  let lastBlockingSize = -1;
+  let lastRegistrySize = -1;
+  let drainTurn = 0;
+  const scheduleFlush = fn => {
+    const attempt = () => {
+      if (registry.size !== lastRegistrySize || drainTurn++ < MIN_DRAIN_TURNS) {
+        if (registry.size !== lastRegistrySize) drainTurn = 0;
+        lastRegistrySize = registry.size;
+        queue(attempt);
+        return;
+      }
+      fn();
+    };
+    const progressed = blockingPromises.size !== lastBlockingSize;
+    lastBlockingSize = blockingPromises.size;
+    lastRegistrySize = -1;
+    drainTurn = 0;
+    progressed ? queue(attempt) : setTimeout(attempt);
+  };
+  let cachedReadable;
+  let consumer;
+  const claimConsumer = name => {
+    if (consumer && consumer !== name) {
+      throw new Error(`renderToStream result was already consumed via \`${consumer}\`; cannot also consume it via \`${name}\`. Use exactly one of \`pipe\`, \`pipeTo\`, or \`readable\`.`);
+    }
+    consumer = name;
+  };
+  const pipeToImpl = w => {
+    let resolve;
+    const p = new Promise(r => resolve = r);
+    function flush() {
       allSettled(blockingPromises).then(() => {
-        setTimeout(() => {
-          doShell();
-          buffer = writable = w;
-          buffer.write(tmp);
-          firstFlushed = true;
-          if (completed) {
-            dispose();
-            writable.end();
-          } else flushEnd();
-        });
-      });
-    },
-    pipeTo(w) {
-      return allSettled(blockingPromises).then(() => {
-        let resolve;
-        const p = new Promise(r => resolve = r);
-        setTimeout(() => {
-          doShell();
+        scheduleFlush(() => {
+          if (dead) return resolve();
+          try {
+            doShell();
+          } catch (err) {
+            failRender(err);
+            return resolve();
+          }
+          if (!shellCompleted) return flush();
           const encoder = new TextEncoder();
           const writer = w.getWriter();
+          let pendingWrites = Promise.resolve();
+          let ended = false;
+          const failed = () => {
+            if (!ended) {
+              abandon();
+              resolve();
+            }
+          };
+          writer.closed && writer.closed.catch(failed);
           writable = {
             end() {
-              writer.releaseLock();
-              w.close();
-              resolve();
+              pendingWrites.then(() => {
+                ended = true;
+                writer.releaseLock();
+                w.close().catch(() => {});
+                resolve();
+              });
             }
           };
           buffer = {
             write(payload) {
-              writer.write(encoder.encode(payload));
+              pendingWrites = pendingWrites.then(() => writer.write(encoder.encode(payload))).catch(failed);
             }
           };
           buffer.write(tmp);
@@ -305,9 +1482,83 @@ function renderToStream(code, options = {}) {
             writable.end();
           } else flushEnd();
         });
-        return p;
       });
     }
+    flush();
+    return p;
+  };
+  return {
+    then(onFulfilled, onRejected) {
+      const p = new Promise(resolve => {
+        function complete() {
+          dispose();
+          resolve(tmp);
+        }
+        if (onCompleteAll) {
+          let ogComplete = onCompleteAll;
+          onCompleteAll = options => {
+            ogComplete(options);
+            complete();
+          };
+        } else onCompleteAll = complete;
+        function flush() {
+          allSettled(blockingPromises).then(() => {
+            scheduleFlush(() => {
+              try {
+                if (!resolveRootHoles() || !headShellReady(headRegistry, p => blockingPromises.add(p))) return flush();
+              } catch (err) {
+                failRender(err);
+                return resolve(tmp);
+              }
+              queue(flushEnd);
+            });
+          });
+        }
+        flush();
+      });
+      return p.then(onFulfilled, onRejected);
+    },
+    pipe(w) {
+      claimConsumer("pipe");
+      function flush() {
+        allSettled(blockingPromises).then(() => {
+          scheduleFlush(() => {
+            if (dead) return;
+            try {
+              doShell();
+            } catch (err) {
+              failRender(err);
+              try {
+                w.end();
+              } catch (_) {}
+              return;
+            }
+            if (!shellCompleted) return flush();
+            buffer = writable = guardSink(w);
+            buffer.write(tmp);
+            firstFlushed = true;
+            if (completed) {
+              dispose();
+              writable.end();
+            } else flushEnd();
+          });
+        });
+      }
+      flush();
+    },
+    pipeTo(w) {
+      claimConsumer("pipeTo");
+      return pipeToImpl(w);
+    },
+    get readable() {
+      claimConsumer("readable");
+      if (!cachedReadable) {
+        const t = new TransformStream();
+        pipeToImpl(t.writable);
+        cachedReadable = t.readable;
+      }
+      return cachedReadable;
+    }
   };
 }
 function HydrationScript(props) {
@@ -319,11 +1570,637 @@ function HydrationScript(props) {
     ...props
   }));
 }
-function ssr(t, ...nodes) {
-  if (nodes.length) return resolveSSR(t, nodes);
+function ssrGroup(fn, n) {
+  fn.$g = n;
+  return fn;
+}
+function buildAsyncWrap(err, node) {
+  const p = ssrHandleError(err);
+  if (!p) return null;
+  if (node.$rw) return {
+    fn: node,
+    p
+  };
+  const owner = getOwner();
+  const live = sharedConfig.context && sharedConfig.context.liveHoles;
+  const suppress = node.$lhSuppress || live && (live.suppressed || live.sweeping);
+  if (!owner) {
+    if (suppress) node.$lhSuppress = true;
+    return {
+      fn: node,
+      p
+    };
+  }
+  const fn = () => runWithOwner(owner, node);
+  fn.$rw = true;
+  if (suppress) fn.$lhSuppress = true;
+  if (node.$lhSkip) fn.$lhSkip = true;
+  if (node.$lhBinding) fn.$lhBinding = node.$lhBinding;
   return {
+    fn,
+    p
+  };
+}
+function ssrFirstGroupHit(hole) {
+  try {
+    return hole();
+  } catch (err) {
+    return buildAsyncWrap(err, hole);
+  }
+}
+function tryResolveFunctionHole(hole) {
+  let value;
+  try {
+    value = hole();
+  } catch (err) {
+    return buildAsyncWrap(err, hole) || "";
+  }
+  const t = typeof value;
+  if (t === "string") return value;
+  if (t === "number") return "" + value;
+  if (value == null || t === "boolean") return "";
+  return tryResolveString(value);
+}
+function mergeTemplateInto(result, node) {
+  result.t[result.t.length - 1] += node.t[0];
+  if (node.t.length > 1) {
+    result.t.push(...node.t.slice(1));
+    result.h.push(...node.h);
+    result.p.push(...node.p);
+  }
+}
+function appendResolvedNode(result, node) {
+  if (node.fn !== undefined) {
+    result.h.push(node.fn);
+    result.p.push(node.p);
+    result.t.push("");
+  } else if (node.merge !== undefined) mergeTemplateInto(result, node.merge);else resolveSSRNode(node.bail, result);
+}
+let _lastGroupFn = null;
+let _lastGroupArr = null;
+let _lastGroupErr = null;
+function ssrGroupSlot(fn, idx) {
+  return () => {
+    if (idx > 0 && _lastGroupFn === fn) {
+      if (_lastGroupArr !== null) return _lastGroupArr[idx];
+      throw _lastGroupErr;
+    }
+    _lastGroupFn = fn;
+    _lastGroupArr = null;
+    _lastGroupErr = null;
+    try {
+      _lastGroupArr = fn();
+      return _lastGroupArr[idx];
+    } catch (err) {
+      _lastGroupErr = err;
+      throw err;
+    }
+  };
+}
+const holePositionCache = new WeakMap();
+function holeContentPositions(t) {
+  let cached = holePositionCache.get(t);
+  if (cached) return cached;
+  const pos = [];
+  const openOff = [];
+  const closeOff = [];
+  let inTag = false;
+  let quote = "";
+  let curOpen = null;
+  let scanningName = false;
+  for (let i = 0; i < t.length; i++) {
+    const seg = t[i];
+    let close = -1;
+    const openAtStart = inTag;
+    let reopened = false;
+    for (let j = 0; j < seg.length; j++) {
+      const ch = seg[j];
+      if (quote) {
+        if (ch === quote) quote = "";
+      } else if (inTag) {
+        if (scanningName && (ch === " " || ch === "\t" || ch === "\n" || ch === ">" || ch === "/")) {
+          scanningName = false;
+          curOpen = {
+            seg: i,
+            off: j
+          };
+        }
+        if (ch === '"' || ch === "'") quote = ch;else if (ch === ">") {
+          inTag = false;
+          if (openAtStart && !reopened && close === -1) close = j;
+          curOpen = null;
+        }
+      } else if (ch === "<") {
+        inTag = true;
+        scanningName = true;
+        reopened = true;
+        curOpen = null;
+      }
+    }
+    if (inTag && scanningName) {
+      scanningName = false;
+      curOpen = {
+        seg: i,
+        off: seg.length
+      };
+    }
+    closeOff.push(close);
+    openOff.push(inTag && curOpen && curOpen.seg === i ? curOpen.off : -1);
+    if (i < t.length - 1) pos.push(!inTag);
+  }
+  cached = {
+    pos,
+    openOff,
+    closeOff
+  };
+  holePositionCache.set(t, cached);
+  return cached;
+}
+function createLiveHoles(sink, scoped) {
+  let nextId = 0;
+  const stamp = typeof creationStamp === "function" ? creationStamp : () => 0;
+  const inScope = scoped && typeof inServerComponentScope === "function" ? inServerComponentScope : null;
+  const stripMarkers = html => html.replace(/<!--lh:\/?\d+-->/g, "");
+  function resolveHoleValue(hole) {
+    const result = {
+      t: [""],
+      h: [],
+      p: []
+    };
+    try {
+      resolveSSRNode(hole(), result);
+    } catch (err) {
+      const wrap = buildAsyncWrap(err, hole);
+      if (!wrap) throw err;
+      result.h.push(wrap.fn);
+      result.p.push(wrap.p);
+      result.t.push("");
+    }
+    return result;
+  }
+  function closeChildren(b) {
+    for (const c of b.children) {
+      c.closed = true;
+      if (c.key) sink.closeBinding(c.key);
+      closeChildren(c);
+    }
+    b.children.length = 0;
+  }
+  const engine = {
+    suppressed: 0,
+    sweeping: false,
+    parent: null,
+    recordStamp: 0,
+    gateHit: false,
+    content(hole) {
+      if (hole.$lhSuppress) {
+        const r = {
+          t: [""],
+          h: [],
+          p: []
+        };
+        engine.suppressed++;
+        try {
+          try {
+            resolveSSRNode(hole(), r);
+          } catch (err) {
+            const wrap = buildAsyncWrap(err, hole);
+            if (wrap) {
+              r.h.push(wrap.fn);
+              r.p.push(wrap.p);
+              r.t.push("");
+            }
+          }
+        } finally {
+          engine.suppressed--;
+        }
+        const b = hole.$lhBinding;
+        if (b && !b.closed && !r.h.length && !engine.sweeping) {
+          b.last = stripMarkers(r.t[0]);
+        }
+        return r.h.length ? r : r.t[0];
+      }
+      if (engine.suppressed || engine.sweeping) return null;
+      if (hole.$lhSkip) return null;
+      if (inScope && !inScope()) return null;
+      const recordsBefore = engine.recordStamp;
+      const ownersBefore = stamp();
+      const owner = getOwner();
+      const b = {
+        key: null,
+        children: [],
+        last: null,
+        closed: false,
+        sweep() {
+          if (b.closed) return;
+          const prevSweeping = engine.sweeping;
+          engine.sweeping = true;
+          engine.gateHit = false;
+          const sweepOwnersBefore = stamp();
+          let res;
+          try {
+            res = owner ? runWithOwner(owner, () => resolveHoleValue(hole)) : resolveHoleValue(hole);
+          } catch (err) {
+            b.closed = true;
+            sink.closeBinding(b.key);
+            sink.error(b.key, String(err && err.message || err));
+            return;
+          } finally {
+            engine.sweeping = prevSweeping;
+          }
+          if (engine.gateHit || stamp() !== sweepOwnersBefore) {
+            b.closed = true;
+            sink.closeBinding(b.key);
+            return;
+          }
+          if (res.h.length) return;
+          const html = res.t[0];
+          if (b.last === null || html === b.last) return;
+          b.last = html;
+          closeChildren(b);
+          sink.hole(b.key, html);
+        }
+      };
+      if (engine.parent) engine.parent.children.push(b);
+      const prevParent = engine.parent;
+      engine.parent = b;
+      let value;
+      let escalated = null;
+      try {
+        value = hole();
+      } catch (err) {
+        const wrap = buildAsyncWrap(err, hole);
+        if (!wrap) {
+          engine.parent = prevParent;
+          closeChildren(b);
+          return "";
+        }
+        escalated = wrap;
+      }
+      if (!escalated && (typeof value === "function" && value.$lhSkip || value !== null && typeof value === "object" && value.$slot)) {
+        engine.parent = prevParent;
+        const r = {
+          t: [""],
+          h: [],
+          p: []
+        };
+        engine.suppressed++;
+        try {
+          resolveSSRNode(value, r);
+        } finally {
+          engine.suppressed--;
+        }
+        return r.h.length ? r : r.t[0];
+      }
+      let res;
+      if (escalated) {
+        closeChildren(b);
+        escalated.fn.$lhSuppress = true;
+        escalated.fn.$lhBinding = b;
+        res = {
+          t: ["", ""],
+          h: [escalated.fn],
+          p: [escalated.p]
+        };
+      } else {
+        res = {
+          t: [""],
+          h: [],
+          p: []
+        };
+        try {
+          resolveSSRNode(value, res);
+        } catch (_) {
+          engine.parent = prevParent;
+          closeChildren(b);
+          return "";
+        }
+      }
+      engine.parent = prevParent;
+      if (engine.recordStamp !== recordsBefore || stamp() !== ownersBefore) {
+        return res.h.length ? res : res.t[0];
+      }
+      const id = nextId++;
+      const key = b.key = "lh:" + id;
+      const open = `<!--lh:${id}-->`;
+      const close = `<!--lh:/${id}-->`;
+      if (!res.h.length) {
+        b.last = stripMarkers(res.t[0]);
+        sink.openBinding(key, b);
+        return open + res.t[0] + close;
+      }
+      const t = res.t.slice();
+      t[0] = open + t[0];
+      t[t.length - 1] += close;
+      sink.openBinding(key, b);
+      return {
+        t,
+        h: res.h,
+        p: res.p
+      };
+    },
+    mint() {
+      return nextId++;
+    },
+    active() {
+      return !inScope || inScope();
+    },
+    attr(cap) {
+      const owner = getOwner();
+      const b = {
+        key: "lha:" + cap.id,
+        children: [],
+        last: cap.base,
+        closed: false,
+        sweep() {
+          if (b.closed) return;
+          const prevSweeping = engine.sweeping;
+          engine.sweeping = true;
+          engine.gateHit = false;
+          const sweepOwnersBefore = stamp();
+          let html = "";
+          try {
+            let group = null;
+            let groupVal = null;
+            const run = () => {
+              for (const part of cap.parts) {
+                if (typeof part === "string") {
+                  html += part;
+                  continue;
+                }
+                let v;
+                if (part.g) {
+                  if (group !== part.g) {
+                    group = part.g;
+                    groupVal = part.g();
+                  }
+                  v = groupVal[part.i];
+                } else {
+                  v = part.f();
+                }
+                const vt = typeof v;
+                if (vt === "string" || vt === "number") html += v;
+              }
+            };
+            owner ? runWithOwner(owner, run) : run();
+          } catch (err) {
+            if (ssrHandleError(err, true)) return;
+            b.closed = true;
+            sink.closeBinding(b.key);
+            sink.error("lha:" + cap.id, String(err && err.message || err));
+            return;
+          } finally {
+            engine.sweeping = prevSweeping;
+          }
+          if (engine.gateHit || stamp() !== sweepOwnersBefore) {
+            b.closed = true;
+            sink.closeBinding(b.key);
+            return;
+          }
+          if (html === b.last) return;
+          const before = attrNames(b.last);
+          const after = attrNames(html);
+          const removed = before.filter(n => !after.includes(n));
+          b.last = html;
+          sink.attr(String(cap.id), html, removed);
+        }
+      };
+      sink.openBinding(b.key, b);
+    }
+  };
+  return engine;
+}
+function attrNames(text) {
+  const names = [];
+  const re = /(?:^|\s)([^\s=/>"']+)(?:="[^"]*")?/g;
+  let m;
+  while (m = re.exec(text)) names.push(m[1]);
+  return names;
+}
+function ssr(t) {
+  const len = arguments.length;
+  if (len === 1) return {
     t
   };
+  let s = t[0];
+  let result = null;
+  let lastGroup = null;
+  let lastGroupVal = null;
+  let lastGroupIdx = 0;
+  const live = sharedConfig.context && sharedConfig.context.liveHoles;
+  const hp = live ? holeContentPositions(t) : null;
+  let lastOpen = null;
+  let cap = null;
+  if (live && hp.openOff[0] >= 0) lastOpen = {
+    r: null,
+    seg: -1,
+    off: hp.openOff[0]
+  };
+  const captureStart = () => {
+    if (cap) return true;
+    if (!lastOpen || live.suppressed || live.sweeping || !live.active()) return false;
+    if (lastOpen.r !== result || result !== null && lastOpen.seg !== result.t.length - 1) {
+      return false;
+    }
+    const id = live.mint();
+    const inject = ` data-lha="${id}"`;
+    let prefix;
+    if (result === null) {
+      s = s.slice(0, lastOpen.off) + inject + s.slice(lastOpen.off);
+      prefix = s.slice(lastOpen.off + inject.length);
+    } else {
+      const seg = result.t[lastOpen.seg];
+      result.t[lastOpen.seg] = seg.slice(0, lastOpen.off) + inject + seg.slice(lastOpen.off);
+      prefix = result.t[lastOpen.seg].slice(lastOpen.off + inject.length);
+    }
+    cap = {
+      id,
+      parts: [prefix],
+      base: prefix
+    };
+    return true;
+  };
+  for (let i = 1; i < len; i++) {
+    const hole = arguments[i];
+    const ht = typeof hole;
+    if (ht === "string") {
+      if (result === null) s += hole;else result.t[result.t.length - 1] += hole;
+      if (cap) {
+        cap.parts.push(hole);
+        cap.base += hole;
+      }
+    } else if (ht === "number") {
+      if (result === null) s += hole;else result.t[result.t.length - 1] += hole;
+      if (cap) {
+        cap.parts.push("" + hole);
+        cap.base += hole;
+      }
+    } else if (hole == null || ht === "boolean") ; else if (ht === "function" && hole.$g) {
+      let value;
+      let hasValue = false;
+      if (lastGroup !== hole) {
+        const r = ssrFirstGroupHit(hole);
+        if (r !== null) {
+          lastGroup = hole;
+          lastGroupVal = r;
+          lastGroupIdx = 0;
+          if (!Array.isArray(r) && result === null) {
+            result = {
+              t: [s],
+              h: [],
+              p: []
+            };
+            s = "";
+          }
+        }
+      }
+      if (lastGroup === hole) {
+        if (Array.isArray(lastGroupVal)) {
+          value = lastGroupVal[lastGroupIdx++];
+          hasValue = true;
+          if (live && !hp.pos[i - 1] && captureStart()) {
+            cap.parts.push({
+              g: hole,
+              i: lastGroupIdx - 1
+            });
+          }
+        } else {
+          cap = null;
+          result.h.push(ssrGroupSlot(lastGroupVal.fn, lastGroupIdx++));
+          result.p.push(lastGroupVal.p);
+          result.t.push("");
+        }
+      }
+      if (hasValue) {
+        const vt = typeof value;
+        if (vt === "string" || vt === "number") {
+          if (result === null) s += value;else result.t[result.t.length - 1] += value;
+          if (cap && !hp.pos[i - 1]) cap.base += value;
+        } else if (value == null || vt === "boolean") ; else if (result !== null) {
+          resolveSSRNode(value, result);
+        } else {
+          const rs = tryResolveString(value);
+          if (typeof rs === "string") {
+            s += rs;
+          } else {
+            result = {
+              t: [s],
+              h: [],
+              p: []
+            };
+            s = "";
+            if (rs.merge !== undefined) mergeTemplateInto(result, rs.merge);else resolveSSRNode(rs.bail, result);
+          }
+        }
+      }
+    } else if (ht === "function") {
+      let liveNode = null;
+      if (live && hp.pos[i - 1] && (liveNode = live.content(hole)) !== null) {
+        if (typeof liveNode === "string") {
+          if (result === null) s += liveNode;else result.t[result.t.length - 1] += liveNode;
+        } else {
+          if (result === null) {
+            result = {
+              t: [s],
+              h: [],
+              p: []
+            };
+            s = "";
+          }
+          resolveSSRNode(liveNode, result);
+        }
+      } else if (result !== null) {
+        const inTag = live && !hp.pos[i - 1];
+        const capturing = inTag && captureStart();
+        const li = capturing ? result.t.length - 1 : 0;
+        const before = capturing ? result.t[li].length : 0;
+        if (live) live.suppressed++;
+        try {
+          resolveSSRNode(hole, result);
+        } finally {
+          if (live) live.suppressed--;
+        }
+        if (capturing) {
+          if (result.t.length - 1 === li) {
+            cap.base += result.t[li].slice(before);
+            cap.parts.push({
+              f: hole
+            });
+          } else {
+            cap = null;
+          }
+        }
+      } else {
+        const capturing = live && !hp.pos[i - 1] && captureStart();
+        const r = tryResolveFunctionHole(hole);
+        if (typeof r === "string") {
+          s += r;
+          if (capturing) {
+            cap.base += r;
+            cap.parts.push({
+              f: hole
+            });
+          }
+        } else {
+          if (capturing) cap = null;
+          result = {
+            t: [s],
+            h: [],
+            p: []
+          };
+          s = "";
+          appendResolvedNode(result, r);
+        }
+      }
+    } else if (result !== null) {
+      resolveSSRNode(hole, result);
+    } else {
+      const r = tryResolveString(hole);
+      if (typeof r === "string") {
+        s += r;
+      } else {
+        result = {
+          t: [s],
+          h: [],
+          p: []
+        };
+        s = "";
+        appendResolvedNode(result, r);
+      }
+    }
+    const next = t[i];
+    if (live) {
+      if (cap) {
+        const co = hp.closeOff[i];
+        if (co >= 0) {
+          const tail = next.slice(0, co);
+          cap.parts.push(tail);
+          cap.base += tail;
+          live.attr(cap);
+          cap = null;
+        } else {
+          cap.parts.push(next);
+          cap.base += next;
+        }
+      }
+      if (hp.openOff[i] >= 0) {
+        lastOpen = result === null ? {
+          r: null,
+          seg: -1,
+          off: s.length + hp.openOff[i]
+        } : {
+          r: result,
+          seg: result.t.length - 1,
+          off: result.t[result.t.length - 1].length + hp.openOff[i]
+        };
+      }
+    }
+    if (result === null) s += next;else result.t[result.t.length - 1] += next;
+  }
+  if (result === null) return {
+    t: s
+  };
+  return result;
 }
 function ssrClassName(value) {
   if (!value) return "";
@@ -336,7 +2213,7 @@ function ssrClassName(value) {
       classValue = !!value[key];
     if (!key || key === "undefined" || !classValue) continue;
     i && (result += " ");
-    result += escape(key);
+    result += escape(key, true);
   }
   return result;
 }
@@ -346,8 +2223,8 @@ function ssrStyle(value) {
   let result = "";
   const k = Object.keys(value);
   for (let i = 0; i < k.length; i++) {
-    const s = k[i];
-    const v = value[s];
+    const s = escape(k[i], true);
+    const v = value[k[i]];
     if (v != undefined) {
       if (i) result += ";";
       const r = escape(v, true);
@@ -362,10 +2239,11 @@ function ssrStyleProperty(name, value) {
   return value != null ? name + value : "";
 }
 function ssrElement(tag, props, children, needsId) {
+  const hk = needsId ? ssrHydrationKey() : "";
   if (props == null) props = {};else if (typeof props === "function") props = props();
   const skipChildren = VOID_ELEMENTS.test(tag);
   const keys = Object.keys(props);
-  let result = `<${tag}${needsId ? ssrHydrationKey() : ""} `;
+  let result = `<${tag}${hk} `;
   for (let i = 0; i < keys.length; i++) {
     const prop = keys[i];
     if (ChildProperties.has(prop)) {
@@ -404,18 +2282,31 @@ function escape(s, attr) {
   const t = typeof s;
   if (t !== "string") {
     if (!attr && Array.isArray(s)) {
+      const joined = tryJoinPlainSSRArray(s);
+      if (joined !== undefined) return joined;
       s = s.slice();
       for (let i = 0; i < s.length; i++) s[i] = escape(s[i]);
       return s;
     }
-    if (attr && t === "boolean") return s;
+    if (attr) {
+      if (s == null || t === "boolean" || t === "number") return s;
+      return escape(String(s), attr);
+    }
     return s;
   }
+  const i = s.search(attr ? ESCAPE_ATTR : ESCAPE_CONTENT);
+  if (i < 0) return s;
+  return escapeSlow(s, attr, i);
+}
+const ESCAPE_CONTENT = /[&<]/;
+const ESCAPE_ATTR = /[&"]/;
+function escapeSlow(s, attr, start) {
   const delim = attr ? '"' : "<";
+  const delimCode = attr ? 34 : 60;
   const escDelim = attr ? "&quot;" : "&lt;";
-  let iDelim = s.indexOf(delim);
-  let iAmp = s.indexOf("&");
-  if (iDelim < 0 && iAmp < 0) return s;
+  const c0 = s.charCodeAt(start);
+  let iDelim = c0 === delimCode ? start : s.indexOf(delim, start);
+  let iAmp = c0 === 38 ? start : s.indexOf("&", start);
   let left = 0,
     out = "";
   while (iDelim >= 0 && iAmp >= 0) {
@@ -446,94 +2337,142 @@ function escape(s, attr) {
   }
   return left < s.length ? out + s.substring(left) : out;
 }
-function mergeProps(...sources) {
-  const target = {};
-  for (let i = 0; i < sources.length; i++) {
-    let source = sources[i];
-    if (typeof source === "function") source = source();
-    if (source) {
-      const descriptors = Object.getOwnPropertyDescriptors(source);
-      for (const key in descriptors) {
-        if (key in target) continue;
-        Object.defineProperty(target, key, {
-          enumerable: true,
-          get() {
-            for (let i = sources.length - 1; i >= 0; i--) {
-              const v = (sources[i] || {})[key];
-              if (v !== undefined) return v;
-            }
-          }
-        });
-      }
+function tryJoinPlainSSRArray(nodes) {
+  if (nodes.length === 0) return undefined;
+  let out = "";
+  for (let i = 0, len = nodes.length; i < len; i++) {
+    const node = nodes[i];
+    if (node == null || typeof node !== "object" || node.h || typeof node.t !== "string") {
+      return undefined;
     }
+    out += node.t;
   }
-  return target;
+  return out;
 }
 function getHydrationKey() {
   const hydrate = sharedConfig.context;
-  return hydrate && !hydrate.noHydrate && sharedConfig.getNextContextId();
-}
-function useAssets(fn) {
-  sharedConfig.context.assets.push(() => resolveSSRSync(escape(fn())));
+  return hydrate && sharedConfig.getNextContextId();
 }
-function getAssets() {
-  const assets = sharedConfig.context.assets;
-  let out = "";
-  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
-  return out;
+function applyRef(r, element) {
+  Array.isArray(r) ? r.flat(Infinity).forEach(f => f && f(element)) : r(element);
 }
 function generateHydrationScript({
   eventNames = ["click", "input"],
   nonce
 } = {}) {
-  return `<script${nonce ? ` nonce="${nonce}"` : ""}>window._$HY||(e=>{let t=e=>e&&e.hasAttribute&&(e.hasAttribute("_hk")?e:t(e.host&&e.host.nodeType?e.host:e.parentNode));["${eventNames.join('", "')}"].forEach((o=>document.addEventListener(o,(o=>{if(!e.events)return;let s=t(o.composedPath&&o.composedPath()[0]||o.target);s&&!e.completed.has(s)&&e.events.push([s,o])}))))})(_$HY={events:[],completed:new WeakSet,r:{},fe(){}});</script><!--xs-->`;
-}
-function Hydration(props) {
-  if (!sharedConfig.context.noHydrate) return props.children;
-  const context = sharedConfig.context;
-  sharedConfig.context = {
-    ...context,
-    noHydrate: false
-  };
-  const res = props.children;
-  sharedConfig.context = context;
-  return res;
-}
-function NoHydration(props) {
-  let context = sharedConfig.context;
-  if (context) sharedConfig.context = {
-    ...context,
-    noHydrate: true
-  };
-  const res = props.children;
-  if (context) sharedConfig.context = context;
-  return res;
+  return `<script${nonce ? ` nonce="${nonce}"` : ""}>window._$HY||(e=>{let t=e=>e&&e.hasAttribute&&(e.hasAttribute("_hk")?e:t(e.host&&e.host.nodeType?e.host:e.parentNode));["${eventNames.join('","')}"].forEach((o=>document.addEventListener(o,(o=>{if(!e.events)return;let s=t(o.composedPath&&o.composedPath()[0]||o.target);s&&!e.completed.has(s)&&e.events.push([s,o])}))))})(_$HY={events:[],completed:new WeakSet,r:{},fe(){}});</script><!--xs-->`;
 }
 function queue(fn) {
   return Promise.resolve().then(fn);
 }
 function allSettled(promises) {
-  let length = promises.length;
+  let size = promises.size;
   return Promise.allSettled(promises).then(() => {
-    if (promises.length !== length) return allSettled(promises);
+    if (promises.size !== size) return allSettled(promises);
     return;
   });
 }
-function injectAssets(assets, html) {
-  if (!assets || !assets.length) return html;
-  let out = "";
-  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
-  const index = html.indexOf("</head>");
-  if (index === -1) return html;
-  return html.slice(0, index) + out + html.slice(index);
+function assembleDocument(html, emittedAssets, inlineStyles, scripts, nonce, headTags, onHead) {
+  const scriptTag = scripts ? `<script${nonce ? ` nonce="${nonce}"` : ""}>${scripts}</script>` : "";
+  const headTagsHtml = headTags ? headTags.html : "";
+  const headPrelude = headTags ? headTags.prelude : "";
+  if (!onHead && !headTagsHtml && !headPrelude && !(emittedAssets && emittedAssets.size) && !(inlineStyles && inlineStyles.size)) {
+    if (!scriptTag) return html;
+    const xs = html.indexOf("<!--xs-->");
+    return xs === -1 ? html + scriptTag : html.slice(0, xs) + scriptTag + html.slice(xs);
+  }
+  if (headPrelude) {
+    const open = html.match(/<head(?:\s[^>]*)?>/);
+    if (open) {
+      const at = open.index + open[0].length;
+      html = html.slice(0, at) + headPrelude + html.slice(at);
+    }
+  }
+  const headIdx = html.indexOf("</head>");
+  if (headIdx === -1) {
+    if (onHead) {
+      onHead(headPrelude + headTagsHtml + renderHeadAssets(emittedAssets, inlineStyles, nonce));
+    }
+    if (!scriptTag) return html;
+    const xs = html.indexOf("<!--xs-->");
+    return xs === -1 ? html + scriptTag : html.slice(0, xs) + scriptTag + html.slice(xs);
+  }
+  const head = headTagsHtml + renderHeadAssets(emittedAssets, inlineStyles, nonce);
+  if (!scriptTag) return html.slice(0, headIdx) + head + html.slice(headIdx);
+  const xsIdx = html.indexOf("<!--xs-->");
+  if (xsIdx === -1) return html.slice(0, headIdx) + head + html.slice(headIdx) + scriptTag;
+  return xsIdx < headIdx ? html.slice(0, xsIdx) + scriptTag + html.slice(xsIdx, headIdx) + head + html.slice(headIdx) : html.slice(0, headIdx) + head + html.slice(headIdx, xsIdx) + scriptTag + html.slice(xsIdx);
+}
+function renderHeadAssets(emittedAssets, inlineStyles, nonce) {
+  let head = "";
+  if (emittedAssets && emittedAssets.size) {
+    for (const url of emittedAssets) {
+      head += isCssUrl(url) ? `<link rel="stylesheet" href="${url}">` : `<link rel="modulepreload" href="${url}">`;
+    }
+  }
+  if (inlineStyles && inlineStyles.size) {
+    for (const entry of inlineStyles.values()) {
+      if (entry.emitted) continue;
+      entry.emitted = true;
+      head += renderInlineStyle(entry, nonce);
+    }
+  }
+  return head;
+}
+function serializeFragmentAssets(key, boundaryModules, context, name = key) {
+  const map = boundaryModules.get(key);
+  if (!map || !Object.keys(map).length) return;
+  context.serialize(name + "_assets", map);
+}
+function propagateBoundaryStyles(childKey, parentKey, tracking) {
+  const childStyles = tracking.getBoundaryStyles(childKey);
+  if (!childStyles) return;
+  let parentStyles = tracking.boundaryStyles.get(parentKey);
+  if (!parentStyles) {
+    parentStyles = new Set();
+    tracking.boundaryStyles.set(parentKey, parentStyles);
+  }
+  for (const url of childStyles) {
+    parentStyles.add(url);
+  }
+}
+function collectStreamStyles(key, tracking, headStyles) {
+  const styles = tracking.getBoundaryStyles(key);
+  const links = [];
+  const inline = [];
+  if (!styles) return {
+    links,
+    inline
+  };
+  for (const entry of styles) {
+    if (typeof entry === "string") {
+      if (!headStyles || !headStyles.has(entry)) links.push(entry);
+    } else if (entry.emitted) {
+      continue;
+    } else if (entry.attrHtml !== undefined) {
+      entry.emitted = true;
+      links.push(entry);
+    } else {
+      entry.emitted = true;
+      inline.push(entry);
+    }
+  }
+  return {
+    links,
+    inline
+  };
 }
-function injectScripts(html, scripts, nonce) {
-  const tag = `<script${nonce ? ` nonce="${nonce}"` : ""}>${scripts}</script>`;
-  const index = html.indexOf("<!--xs-->");
-  if (index > -1) {
-    return html.slice(0, index) + tag + html.slice(index);
+function escapeStyleContent(content) {
+  return content.replace(/<\/(style)/gi, "<\\/$1");
+}
+function renderInlineStyle(entry, nonce) {
+  let attrs = "";
+  if (entry.attrs) {
+    for (const name in entry.attrs) {
+      attrs += ` ${name}="${escape(String(entry.attrs[name]), true)}"`;
+    }
   }
-  return html + tag;
+  return `<style${nonce ? ` nonce="${nonce}"` : ""} data-asset="${escape(entry.id, true)}"${attrs}>${escapeStyleContent(entry.content)}</style>`;
 }
 function waitForFragments(registry, key) {
   for (const k of [...registry.keys()].reverse()) {
@@ -563,19 +2502,48 @@ function flattenClassList(list, result) {
     if (Array.isArray(item)) flattenClassList(item, result);else if (typeof item === "object" && item != null) Object.assign(result, item);else if (item || item === 0) result[item] = true;
   }
 }
-function resolveSSR(template, holes, result = {
-  t: [""],
-  h: [],
-  p: []
-}) {
-  for (let i = 0; i < holes.length; i++) {
-    const hole = holes[i];
-    result.t[result.t.length - 1] += template[i];
-    if (hole == null || hole === true || hole === false) continue;
-    resolveSSRNode(hole, result);
+function tryResolveString(node) {
+  const t = typeof node;
+  if (t === "string") return node;
+  if (t === "number") return "" + node;
+  if (node == null || t === "boolean") return "";
+  if (t === "object") {
+    if (Array.isArray(node)) {
+      const joined = tryJoinPlainSSRArray(node);
+      if (joined !== undefined) return joined;
+      let s = "";
+      let prevNonObj = false;
+      for (let i = 0, len = node.length; i < len; i++) {
+        const item = node[i];
+        const itemNonObj = item !== null && typeof item !== "object";
+        if (prevNonObj && itemNonObj) s += "<!--!$-->";
+        prevNonObj = itemNonObj;
+        const r = tryResolveString(item);
+        if (typeof r !== "string") return {
+          bail: node
+        };
+        s += r;
+      }
+      return s;
+    }
+    if (node.h && node.h.length > 0) return {
+      merge: node
+    };
+    if (node.t === undefined) {
+      return "";
+    }
+    return Array.isArray(node.t) ? node.t[0] : node.t;
   }
-  result.t[result.t.length - 1] += template[template.length - 1];
-  return result;
+  if (t === "function") {
+    let v;
+    try {
+      v = node();
+    } catch (err) {
+      return buildAsyncWrap(err, node) || "";
+    }
+    return tryResolveString(v);
+  }
+  return "";
 }
 function resolveSSRNode(node, result = {
   t: [""],
@@ -586,10 +2554,19 @@ function resolveSSRNode(node, result = {
   if (t === "string" || t === "number") {
     result.t[result.t.length - 1] += node;
   } else if (node == null || t === "boolean") ; else if (Array.isArray(node)) {
-    let prev = {};
-    for (let i = 0, len = node.length; i < len; i++) {
-      if (!top && typeof prev !== "object" && typeof node[i] !== "object") result.t[result.t.length - 1] += `<!--!$-->`;
-      resolveSSRNode(prev = node[i], result);
+    const slotLive = node.$slot && sharedConfig.context && sharedConfig.context.liveHoles;
+    if (slotLive) slotLive.suppressed++;
+    try {
+      let prevNonObj = false;
+      for (let i = 0, len = node.length; i < len; i++) {
+        const item = node[i];
+        const itemNonObj = item !== null && typeof item !== "object";
+        if (!top && prevNonObj && itemNonObj) result.t[result.t.length - 1] += `<!--!$-->`;
+        prevNonObj = itemNonObj;
+        resolveSSRNode(item, result);
+      }
+    } finally {
+      if (slotLive) slotLive.suppressed--;
     }
   } else if (t === "object") {
     if (node.h) {
@@ -599,16 +2576,24 @@ function resolveSSRNode(node, result = {
         result.h.push(...node.h);
         result.p.push(...node.p);
       }
-    } else result.t[result.t.length - 1] += node.t;
+    } else if (node.t !== undefined) {
+      result.t[result.t.length - 1] += node.t;
+    } else ;
   } else if (t === "function") {
-    try {
-      resolveSSRNode(node(), result);
-    } catch (err) {
-      const p = ssrHandleError(err);
-      if (p) {
-        result.h.push(node);
-        result.p.push(p);
-        result.t.push("");
+    const live = sharedConfig.context && sharedConfig.context.liveHoles;
+    let liveNode = null;
+    if (live && (liveNode = live.content(node)) !== null) {
+      if (typeof liveNode === "string") result.t[result.t.length - 1] += liveNode;else resolveSSRNode(liveNode, result);
+    } else {
+      try {
+        resolveSSRNode(node(), result);
+      } catch (err) {
+        const wrap = buildAsyncWrap(err, node);
+        if (wrap) {
+          result.h.push(wrap.fn);
+          result.p.push(wrap.p);
+          result.t.push("");
+        }
       }
     }
   }
@@ -617,36 +2602,376 @@ function resolveSSRNode(node, result = {
 function resolveSSRSync(node) {
   const res = resolveSSRNode(node);
   if (!res.h.length) return res.t[0];
-  throw new Error("This value cannot be rendered synchronously. Are you missing a Suspsense boundary?");
+  throw new Error("This value cannot be rendered synchronously. Are you missing a boundary?");
 }
-const RequestContext = Symbol();
+const RequestContext = Symbol.for("solid.RequestContext");
 function getRequestEvent() {
-  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || sharedConfig.context && sharedConfig.context.event || console.log("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || sharedConfig.context && sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+}
+function createResponseStub() {
+  return {
+    status: undefined,
+    statusText: undefined,
+    headers: new Headers(),
+    committed: false
+  };
+}
+function createRequestEvent(request, init) {
+  return {
+    request,
+    locals: {},
+    response: createResponseStub(),
+    ...init
+  };
+}
+function reportLostHeaderWrite(method, name) {
+  const message = `Response header write dropped: headers.${method}(${JSON.stringify(String(name))}) ` + "ran after the response head was sent. Write headers before the shell flushes " + "(or before the handler returns).";
+  console.error(message);
+}
+function commitResponseStub(stub, {
+  allowLateLocation = false
+} = {}) {
+  if (!stub || stub.committed) return stub;
+  stub.committed = true;
+  const headers = stub.headers;
+  if (!headers || typeof headers.set !== "function") return stub;
+  for (const method of ["set", "append", "delete"]) {
+    const original = headers[method].bind(headers);
+    headers[method] = function (name, ...rest) {
+      if (allowLateLocation && method === "set" && String(name).toLowerCase() === "location") {
+        return original(name, ...rest);
+      }
+      reportLostHeaderWrite(method, name);
+    };
+  }
+  return stub;
+}
+const validRedirectStatuses = /*#__PURE__*/new Set([301, 302, 303, 307, 308]);
+function getExpectedRedirectStatus(response) {
+  if (response.status && validRedirectStatuses.has(response.status)) return response.status;
+  return 302;
+}
+function mergeStubHeaders(target, stub) {
+  if (!stub) return target;
+  stub.headers.forEach((value, key) => {
+    if (key !== "set-cookie") target.set(key, value);
+  });
+  const setCookies = stub.headers.getSetCookie ? stub.headers.getSetCookie() : [];
+  for (const cookie of setCookies) target.append("set-cookie", cookie);
+  return target;
 }
-function renderToStringAsync(code, options = {}) {
-  return renderToStream(code, options).then(html => html);
+function copyInitHeaders(init) {
+  if (!init || !init.getSetCookie) return new Headers(init);
+  const headers = new Headers();
+  init.forEach((value, key) => {
+    if (key !== "set-cookie") headers.append(key, value);
+  });
+  for (const cookie of init.getSetCookie()) headers.append("Set-Cookie", cookie);
+  return headers;
+}
+const STUB_GAP_FILL_EXCLUDED = /*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, "Location"].map(header => header.toLowerCase()));
+function fillsStubGap(key, headers, response) {
+  if (key === "set-cookie" || STUB_GAP_FILL_EXCLUDED.has(key)) return false;
+  if (response.body === null && (key === "content-type" || key === "content-length")) return false;
+  return !headers.has(key);
+}
+function commitEventResponse(response, event = getRequestEvent()) {
+  const stub = event && event.response;
+  if (!stub || !stub.headers || stub.committed) return response;
+  const cookies = stub.headers.getSetCookie ? stub.headers.getSetCookie() : [];
+  commitResponseStub(stub);
+  let hasGaps = false;
+  stub.headers.forEach((value, key) => {
+    if (fillsStubGap(key, response.headers, response)) hasGaps = true;
+  });
+  if (!cookies.length && !hasGaps) return response;
+  try {
+    for (const cookie of cookies) response.headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, response.headers, response)) response.headers.set(key, value);
+    });
+    return response;
+  } catch {
+    const headers = copyInitHeaders(response.headers);
+    for (const cookie of cookies) headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, headers, response)) headers.set(key, value);
+    });
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+function deriveHead(stub, responseInit = {}) {
+  const headers = mergeStubHeaders(copyInitHeaders(responseInit.headers), stub);
+  const status = stub && stub.status || responseInit.status || 200;
+  const statusText = stub && stub.statusText || responseInit.statusText || undefined;
+  return {
+    status,
+    statusText,
+    headers
+  };
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function createSSRResponse(result, event, options = {}) {
+  const stub = event && event.response;
+  const {
+    responseInit,
+    nonce,
+    transformChunk
+  } = options;
+  if (typeof result === "string") {
+    if (stub) commitResponseStub(stub);
+    const head = deriveHead(stub, responseInit);
+    if (stub && stub.headers.get("Location")) {
+      return new Response(null, {
+        status: getExpectedRedirectStatus(stub),
+        headers: head.headers
+      });
+    }
+    if (!head.headers.has("content-type")) {
+      head.headers.set("content-type", "text/html; charset=utf-8");
+    }
+    return new Response(transformChunk ? transformChunk(result) : result, {
+      status: head.status,
+      statusText: head.statusText,
+      headers: head.headers
+    });
+  }
+  const encoder = new TextEncoder();
+  return new Promise(resolve => {
+    let controller;
+    let closed = false;
+    let flushed = false;
+    const enqueue = value => {
+      if (closed || !controller) return;
+      try {
+        controller.enqueue(encoder.encode(value));
+      } catch {
+        closed = true;
+      }
+    };
+    result.pipe({
+      write(chunk) {
+        if (!flushed) {
+          flushed = true;
+          if (stub) commitResponseStub(stub, {
+            allowLateLocation: true
+          });
+          const head = deriveHead(stub, responseInit);
+          if (stub && stub.headers.get("Location")) {
+            closed = true;
+            resolve(new Response(null, {
+              status: getExpectedRedirectStatus(stub),
+              headers: head.headers
+            }));
+            return;
+          }
+          if (!head.headers.has("content-type")) {
+            head.headers.set("content-type", "text/html; charset=utf-8");
+          }
+          resolve(new Response(new ReadableStream({
+            start(c) {
+              controller = c;
+            },
+            cancel() {
+              closed = true;
+            }
+          }), {
+            status: head.status,
+            statusText: head.statusText,
+            headers: head.headers
+          }));
+        }
+        enqueue(transformChunk ? transformChunk(chunk) : chunk);
+      },
+      end() {
+        if (closed || !controller) return;
+        const location = stub && stub.headers.get("Location");
+        if (location) {
+          const attr = nonce ? ` nonce="${escapeAttribute(nonce)}"` : "";
+          enqueue(`<script${attr}>window.location=${JSON.stringify(location).replace(/</g, "\\u003c")}</script>`);
+        }
+        closed = true;
+        try {
+          controller.close();
+        } catch {}
+      }
+    });
+  });
+}
+function composeMiddleware(middlewares) {
+  return function run(request, next) {
+    let index = -1;
+    function dispatch(i, req) {
+      if (i <= index) return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      if (i === middlewares.length) return Promise.resolve(next(req));
+      return Promise.resolve(middlewares[i](req, override => dispatch(i + 1, override || req)));
+    }
+    return dispatch(0, request);
+  };
+}
+function registerElementClaim() {
+  return noopCleanup;
+}
+function noopCleanup() {}
+function claimElement(node) {
+  return node;
+}
+function claimElementTree(root) {
+  return root;
 }
 function notSup() {
   throw new Error("Client-only API called on the server side. Run client-only code in onMount, or conditionally run client-only component with <Show>.");
 }
 
+setContainerTraceResolver(getProjectionTrace);
 const isServer = true;
 const isDev = false;
-function createDynamic(component, props) {
-  const comp = component(),
-    t = typeof comp;
-  if (comp) {
-    if (t === "function") return comp(props);else if (t === "string") {
-      return ssrElement(comp, props, undefined, true);
-    }
-  }
+function dynamic(source) {
+  const cached = createMemo(source, {
+    serialize: false
+  });
+  return props => {
+    return createMemo(() => {
+      const c = cached();
+      if (c) {
+        if (typeof c === "function") return c(props);
+        if (typeof c === "string") {
+          return ssrElement(c, props, undefined, true);
+        }
+      }
+    }, {
+      sync: true
+    });
+  };
 }
 function Dynamic(props) {
-  const others = omit(props, "component");
-  return createDynamic(() => props.component, others);
+  const Comp = dynamic(() => props.component);
+  return createComponent(Comp, omit(props, "component"));
 }
 function Portal(props) {
-  throw new Error("Portal is not supported on the server");
+  const o = getOwner();
+  if (o?.id != null) getNextChildId(o);
+  return undefined;
+}
+function registerClientOnlyPreload(moduleUrl) {
+  const ctx = sharedConfig.context;
+  if (!ctx?.registerAsset || !ctx.resolveAssets) return;
+  const registerAsset = ctx.registerAsset;
+  const resolve = ctx.resolveAssets;
+  const apply = assets => {
+    if (!assets) return;
+    for (let i = 0; i < assets.css.length; i++) {
+      const css = assets.css[i];
+      if (typeof css === "string") registerAsset("style", css);else registerAsset("inline-style", css);
+    }
+    for (let i = 0; i < assets.js.length; i++) registerAsset("module", assets.js[i]);
+  };
+  const assets = resolve(moduleUrl);
+  if (assets && typeof assets.then === "function") {
+    const boundary = ctx._currentBoundaryId;
+    assets.then(resolved => {
+      const current = ctx._currentBoundaryId;
+      ctx._currentBoundaryId = boundary;
+      try {
+        apply(resolved);
+      } finally {
+        ctx._currentBoundaryId = current;
+      }
+    },
+    () => {});
+  } else {
+    apply(assets);
+  }
+}
+function clientOnly(_fn, _options = {}, moduleUrl) {
+  return props => {
+    if (moduleUrl) registerClientOnlyPreload(moduleUrl);
+    return createMemo(() => props.fallback);
+  };
+}
+const statusLedgers = /* @__PURE__ */new WeakMap();
+const headerLedgers = /* @__PURE__ */new WeakMap();
+function httpStatus(code, text) {
+  const event = getRequestEvent();
+  const response = event && event.response;
+  if (response && !response.committed) {
+    let ledger = statusLedgers.get(response);
+    if (!ledger) {
+      ledger = {
+        base: {
+          status: response.status,
+          statusText: response.statusText
+        },
+        live: []
+      };
+      statusLedgers.set(response, ledger);
+    }
+    const declaration = {
+      status: code,
+      statusText: text
+    };
+    ledger.live.push(declaration);
+    response.status = code;
+    response.statusText = text;
+    onCleanup(() => {
+      if (response.committed) return;
+      const index = ledger.live.indexOf(declaration);
+      if (index < 0) return;
+      ledger.live.splice(index, 1);
+      const effective = ledger.live.length ? ledger.live[ledger.live.length - 1] : ledger.base;
+      response.status = effective.status;
+      response.statusText = effective.statusText;
+      if (!ledger.live.length) statusLedgers.delete(response);
+    });
+  }
+}
+function httpHeader(name, value, options) {
+  const event = getRequestEvent();
+  const response = event && event.response;
+  if (response && !response.committed) {
+    const headers = response.headers;
+    const key = name.toLowerCase();
+    const setCookie = key === "set-cookie";
+    let ledgers = headerLedgers.get(response);
+    if (!ledgers) headerLedgers.set(response, ledgers = new Map());
+    let ledger = ledgers.get(key);
+    if (!ledger) {
+      ledger = {
+        base: setCookie ? headers.getSetCookie() : headers.get(name),
+        live: []
+      };
+      ledgers.set(key, ledger);
+    }
+    const declaration = {
+      value,
+      append: !!(options && options.append)
+    };
+    ledger.live.push(declaration);
+    if (declaration.append) headers.append(name, value);else headers.set(name, value);
+    onCleanup(() => {
+      if (response.committed) return;
+      const index = ledger.live.indexOf(declaration);
+      if (index < 0) return;
+      ledger.live.splice(index, 1);
+      headers.delete(name);
+      if (setCookie) {
+        for (const cookie of ledger.base) headers.append(name, cookie);
+      } else if (ledger.base !== null) {
+        headers.set(name, ledger.base);
+      }
+      for (const d of ledger.live) {
+        if (d.append) headers.append(name, d.value);else headers.set(name, d.value);
+      }
+      if (!ledger.live.length) ledgers.delete(key);
+    });
+  }
 }
 
-export { ChildProperties, DOMElements, DelegatedEvents, Dynamic, Hydration, HydrationScript, NoHydration, Portal, Properties, RequestContext, SVGElements, SVGNamespace, notSup as addEventListener, notSup as assign, notSup as className, createDynamic, notSup as delegateEvents, notSup as dynamicProperty, escape, generateHydrationScript, getAssets, getHydrationKey, notSup as getNextElement, notSup as getNextMarker, notSup as getNextMatch, getRequestEvent, notSup as hydrate, notSup as insert, isDev, isServer, memo, mergeProps, notSup as render, renderToStream, renderToString, renderToStringAsync, notSup as runHydrationEvents, notSup as setAttribute, notSup as setAttributeNS, notSup as setProperty, notSup as spread, ssr, ssrAttribute, ssrClassName, ssrElement, ssrHydrationKey, ssrStyle, ssrStyleProperty, notSup as style, notSup as template, useAssets };
+export { ChildProperties, DOMElements, DOMWithState, DelegatedEvents, Dynamic, HREF, HydrationScript, MathMLElements, Namespaces, Portal, REVALIDATE_HEADER, RawTextElements, RequestContext, ResponseEnvelope, SAFE_ERROR, SVGElements, VoidElements, notSup as acquireAsset, notSup as addEvent, applyRef, notSup as assign, claimElement, claimElementTree, notSup as className, clearFlashCookie, clientOnly, commitEventResponse, commitResponseStub, composeMiddleware, createLiveHoles, createRequestEvent, createResponseStub, createSSRResponse, notSup as delegateEvents, dynamic, notSup as dynamicProperty, effect, escape, generateHydrationScript, notSup as getDelegatedRoot, getExpectedRedirectStatus, getHydrationKey, notSup as getNextElement, notSup as getNextMarker, notSup as getNextMatch, getRequestEvent, getServerFunctionMetadata, getServerFunctionRPC, hasFlashCookie, httpHeader, httpStatus, notSup as hydrate, notSup as insert, isDev, isHref, isResponseEnvelope, isSafeError, isServer, isServerFunction, markSafeError, memo, parseCookieHeader, redirect, notSup as ref, notSup as registerDelegatedContainer, notSup as registerDelegatedRoot, registerElementClaim, reload, notSup as render, renderToStream, renderToString, respond, notSup as runHydrationEvents, serializeCookie, notSup as setAttribute, notSup as setAttributeNS, notSup as setProperty, notSup as setStyleProperty, notSup as spread, ssr, ssrAttribute, ssrClassName, ssrElement, ssrGroup, ssrHydrationKey, ssrStyle, ssrStyleProperty, notSup as style, notSup as template, notSup as unregisterDelegatedContainer, notSup as unregisterDelegatedRoot, useHead };