@solidjs/web 2.0.0-beta.32 → 2.0.0-beta.34

package/dist/server.js

@@ -1,6 +1,6 @@
-import { createRenderEffect, createMemo, sharedConfig, createRoot, ssrHandleError, getOwner, runWithOwner, createComponent, omit, getNextChildId, onCleanup } 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 { Serializer, getCrossReferenceHeader, Feature } from 'seroval';
+import { Feature, Serializer, getCrossReferenceHeader } from 'seroval';
 import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
 
 const DOMWithState = {
@@ -63,15 +63,74 @@ const effect = (fn, effectFn, options) => createRenderEffect(fn, effectFn, optio
 } : transparentOptions);
 const memo = fn => createMemo(() => fn(), syncOptions);
 
-const DEFAULT_DISABLED_FEATURES = Feature.AggregateError | Feature.BigIntTypedArray;
-const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : Feature.ErrorPrototypeStack;
-const HYDRATION_GLOBAL = "_$HY.r";
+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]);
+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,
@@ -98,16 +157,19 @@ function createHydrationSerializer({
 function getLocalHeaderScript(id) {
   return getCrossReferenceHeader(id) + ";";
 }
-Feature.RegExp;
 
 const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
-class ResponseEnvelope {
-  constructor(response, value) {
-    this.response = response;
-    this.value = value;
+// 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;
+  ResponseEnvelope.prototype[ENVELOPE] = true;
+  return ResponseEnvelope;
+})();
 function isResponseEnvelope(value) {
   return !!(value && typeof value === "object" && value[ENVELOPE]);
 }
@@ -194,9 +256,18 @@ function respond(value, init = {}) {
   }), value);
 }
 
-const ERROR_HEADER = "X-Server-Function-Error";
-const BODY_FORMAT_HEADER = "X-Server-Function-Format";
-const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
+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 = {};
@@ -234,6 +305,18 @@ function serializeCookie(name, value, options = {}) {
   }
   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_:.-]*$/;
@@ -305,7 +388,6 @@ function resolveHead(groups) {
     }
     for (const [identity, tags] of byIdentity) {
       if (identity === "title") {
-        if (tags.length > 1) console.warn("Multiple <title> tags in one head group; the last one wins.");
         winners.set(identity, {
           seq: group.seq,
           tags: [tags[tags.length - 1]]
@@ -495,7 +577,6 @@ function registerHeadTags(registry, context, tracking, emitResource, nonce, tags
   for (let i = 0; i < tags.length; i++) {
     const desc = tags[i];
     if (!desc || !HEAD_ELIGIBLE_TAGS.has(desc.tag)) {
-      console.warn(`useHead: ignoring non-head tag`, desc);
       continue;
     }
     const cls = classifyHeadTag(desc);
@@ -547,7 +628,6 @@ function headShellReady(registry, block) {
       } : undefined);
     } catch (err) {
       if (pends(err)) continue;
-      console.warn(`useHead: error evaluating resource tag props`, err);
       parked.splice(i, 1);
       continue;
     }
@@ -588,7 +668,6 @@ function emitHeadResource(registry, context, tracking, emitResource, nonce, desc
       });
       return;
     }
-    console.warn(`useHead: error evaluating resource tag props`, err);
     return;
   }
   const identity = resourceIdentity(desc.tag, props);
@@ -650,7 +729,6 @@ function commitHeadBoundary(registry, boundary, isPendingFragment) {
       try {
         resolved = reg.list();
       } catch (err) {
-        console.warn(`useHead: error evaluating head group membership`, err);
         continue;
       }
       if (!Array.isArray(resolved)) resolved = [resolved];
@@ -658,7 +736,6 @@ function commitHeadBoundary(registry, boundary, isPendingFragment) {
       for (let j = 0; j < resolved.length; j++) {
         const desc = resolved[j];
         if (!desc || !HEAD_ELIGIBLE_TAGS.has(desc.tag)) {
-          console.warn(`useHead: ignoring non-head tag`, desc);
           continue;
         }
         const cls = classifyHeadTag(desc);
@@ -684,12 +761,10 @@ function commitHeadBoundary(registry, boundary, isPendingFragment) {
         } : undefined);
         key = evalHeadValue(desc.key);
       } catch (err) {
-        console.warn(`useHead: error evaluating tag props`, err);
         continue;
       }
       const identity = replaceableIdentity(desc.tag, props, key, "u:" + registry.uniq++);
       if ((identity === "base" || identity === "charset") && registry.shellFlushed) {
-        console.warn(`useHead: <${desc.tag}> (${identity}) registered after shell flush is ignored`);
         continue;
       }
       tags.push({
@@ -771,7 +846,6 @@ function flushHeadFragment(registry, boundary) {
       for (const name in t.props) {
         if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
         if (!HEAD_ATTR_NAME.test(name)) {
-          console.warn(`useHead: ignoring invalid attribute name "${name}"`);
           continue;
         }
         const v = t.props[name];
@@ -789,7 +863,6 @@ function renderHeadAttrHtml(props) {
   for (const name in props) {
     if (name === "children" || name === "ref" || name.slice(0, 2) === "on") continue;
     if (!HEAD_ATTR_NAME.test(name)) {
-      console.warn(`useHead: ignoring invalid attribute name "${name}"`);
       continue;
     }
     const v = props[name];
@@ -822,7 +895,6 @@ function renderHeadTagMarkup(tag, props, identity, nonce) {
 function useHead(tags) {
   const ctx = sharedConfig.context;
   if (!ctx || !ctx.registerHeadTags) {
-    console.warn("useHead() called outside of a server render; registration ignored.");
     return;
   }
   ctx.registerHeadTags(tags);
@@ -892,7 +964,7 @@ function renderToString(code, options = {}) {
   }, {
     id: renderId
   });
-  serializeFragmentAssets("", tracking.boundaryModules, sharedConfig.context);
+  serializeFragmentAssets("", tracking.boundaryModules, sharedConfig.context, renderId);
   sharedConfig.context.noHydrate = true;
   serializer.close();
   const head = renderShellHead(headRegistry, nonce, null);
@@ -926,6 +998,12 @@ function renderToStream(code, options = {}) {
       d();
     }
   };
+  const failRender = err => {
+    try {
+      options.onError ? options.onError(err) : console.error(err);
+    } catch (_) {}
+    abandon();
+  };
   const guardSink = w => ({
     write(payload) {
       if (dead) return;
@@ -1022,12 +1100,20 @@ function renderToStream(code, options = {}) {
   const serializeRootAssets = () => {
     if (rootAssetsSerialized) return;
     rootAssetsSerialized = true;
-    serializeFragmentAssets("", tracking.boundaryModules, context);
+    serializeFragmentAssets("", tracking.boundaryModules, context, renderId);
   };
+  let holds = 0;
   const flushEnd = () => {
-    if (!registry.size) {
+    if (!registry.size && !holds) {
       serializeRootAssets();
-      queue(() => queue(() => serializer.flush()));
+      queue(() => queue(() => {
+        if (context.live.end) {
+          const end = context.live.end;
+          context.live.end = null;
+          end();
+        }
+        serializer.flush();
+      }));
     }
   };
   const registry = new Map();
@@ -1088,6 +1174,7 @@ function renderToStream(code, options = {}) {
   sharedConfig.context = context = {
     async: true,
     nonce,
+    live: {},
     registerHeadTags(tags) {
       registerHeadTags(headRegistry, context, tracking,
       (markup, gateEntry) => {
@@ -1124,6 +1211,16 @@ function renderToStream(code, options = {}) {
     block(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;
       const placeholder = `<!--!$${id}-->`;
@@ -1232,6 +1329,7 @@ function renderToStream(code, options = {}) {
     }
   };
   applyAssetTracking(context, tracking, manifest, noScripts);
+  context.failRender = failRender;
   registerEntryAssets(manifest);
   let html = createRoot(d => {
     dispose = d;
@@ -1344,7 +1442,12 @@ function renderToStream(code, options = {}) {
       allSettled(blockingPromises).then(() => {
         scheduleFlush(() => {
           if (dead) return resolve();
-          doShell();
+          try {
+            doShell();
+          } catch (err) {
+            failRender(err);
+            return resolve();
+          }
           if (!shellCompleted) return flush();
           const encoder = new TextEncoder();
           const writer = w.getWriter();
@@ -1401,7 +1504,12 @@ function renderToStream(code, options = {}) {
         function flush() {
           allSettled(blockingPromises).then(() => {
             scheduleFlush(() => {
-              if (!resolveRootHoles() || !headShellReady(headRegistry, p => blockingPromises.add(p))) return flush();
+              try {
+                if (!resolveRootHoles() || !headShellReady(headRegistry, p => blockingPromises.add(p))) return flush();
+              } catch (err) {
+                failRender(err);
+                return resolve(tmp);
+              }
               queue(flushEnd);
             });
           });
@@ -1416,7 +1524,15 @@ function renderToStream(code, options = {}) {
         allSettled(blockingPromises).then(() => {
           scheduleFlush(() => {
             if (dead) return;
-            doShell();
+            try {
+              doShell();
+            } catch (err) {
+              failRender(err);
+              try {
+                w.end();
+              } catch (_) {}
+              return;
+            }
             if (!shellCompleted) return flush();
             buffer = writable = guardSink(w);
             buffer.write(tmp);
@@ -1461,9 +1577,27 @@ function ssrGroup(fn, n) {
 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: owner ? () => runWithOwner(owner, node) : node,
+    fn,
     p
   };
 }
@@ -1523,6 +1657,326 @@ function ssrGroupSlot(fn, idx) {
     }
   };
 }
+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 {
@@ -1533,13 +1987,54 @@ function ssr(t) {
   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;
@@ -1563,7 +2058,14 @@ function ssr(t) {
         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("");
@@ -1573,6 +2075,7 @@ function ssr(t) {
         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 {
@@ -1590,19 +2093,67 @@ function ssr(t) {
           }
         }
       }
-    } else if (result !== null) {
-      resolveSSRNode(hole, result);
     } else if (ht === "function") {
-      const r = tryResolveFunctionHole(hole);
-      if (typeof r === "string") s += r;else {
-        result = {
-          t: [s],
-          h: [],
-          p: []
-        };
-        s = "";
-        appendResolvedNode(result, r);
+      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") {
@@ -1618,6 +2169,32 @@ function ssr(t) {
       }
     }
     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 {
@@ -1842,10 +2419,10 @@ function renderHeadAssets(emittedAssets, inlineStyles, nonce) {
   }
   return head;
 }
-function serializeFragmentAssets(key, boundaryModules, context) {
+function serializeFragmentAssets(key, boundaryModules, context, name = key) {
   const map = boundaryModules.get(key);
   if (!map || !Object.keys(map).length) return;
-  context.serialize(key + "_assets", map);
+  context.serialize(name + "_assets", map);
 }
 function propagateBoundaryStyles(childKey, parentKey, tracking) {
   const childStyles = tracking.getBoundaryStyles(childKey);
@@ -1953,7 +2530,6 @@ function tryResolveString(node) {
       merge: node
     };
     if (node.t === undefined) {
-      console.warn(`Unrecognized value. Skipped inserting`, node);
       return "";
     }
     return Array.isArray(node.t) ? node.t[0] : node.t;
@@ -1978,13 +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 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);
+    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) {
@@ -1996,16 +2578,22 @@ function resolveSSRNode(node, result = {
       }
     } else if (node.t !== undefined) {
       result.t[result.t.length - 1] += node.t;
-    } else console.warn(`Unrecognized value. Skipped inserting`, node);
+    } else ;
   } else if (t === "function") {
-    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("");
+    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("");
+        }
       }
     }
   }
@@ -2038,7 +2626,7 @@ function createRequestEvent(request, 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).";
-  throw new Error(message);
+  console.error(message);
 }
 function commitResponseStub(stub, {
   allowLateLocation = false
@@ -2242,6 +2830,7 @@ 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 dynamic(source) {
@@ -2307,18 +2896,39 @@ function clientOnly(_fn, _options = {}, 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) {
-    const prevStatus = response.status;
-    const prevStatusText = response.statusText;
+    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;
-      response.status = prevStatus;
-      response.statusText = prevStatusText;
+      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);
     });
   }
 }
@@ -2327,18 +2937,41 @@ function httpHeader(name, value, options) {
   const response = event && event.response;
   if (response && !response.committed) {
     const headers = response.headers;
-    const setCookie = name.toLowerCase() === "set-cookie";
-    const prevCookies = setCookie ? headers.getSetCookie() : undefined;
-    const prev = setCookie ? null : headers.get(name);
-    if (options && options.append) headers.append(name, value);else headers.set(name, value);
+    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) {
-        headers.delete(name);
-        for (const cookie of prevCookies) headers.append(name, cookie);
-      } else if (prev === null) headers.delete(name);else headers.set(name, prev);
+        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, 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, clientOnly, commitEventResponse, commitResponseStub, composeMiddleware, 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, httpHeader, httpStatus, notSup as hydrate, notSup as insert, isDev, isHref, isResponseEnvelope, isSafeError, isServer, 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 };
+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 };