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

package/dist/server.cjs

@@ -64,15 +64,74 @@ const effect = (fn, effectFn, options) => solidJs.createRenderEffect(fn, effectF
 } : transparentOptions);
 const memo = fn => solidJs.createMemo(() => fn(), syncOptions);
 
-const DEFAULT_DISABLED_FEATURES = seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
-const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : seroval.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([web.AbortSignalPlugin,
 web.CustomEventPlugin, web.DOMExceptionPlugin, web.EventPlugin,
-web.FormDataPlugin, web.HeadersPlugin, web.ReadableStreamPlugin, web.RequestPlugin, web.ResponsePlugin, web.URLSearchParamsPlugin, web.URLPlugin]);
+web.FormDataPlugin, web.HeadersPlugin, web.ReadableStreamPlugin, web.RequestPlugin, web.ResponsePlugin, web.URLSearchParamsPlugin, web.URLPlugin,
+ContainerTracePlugin]);
 function resolveSerializerPlugins(customPlugins) {
   return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
 }
+seroval.Feature.RegExp;
+
+const DEFAULT_DISABLED_FEATURES = seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
+const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : seroval.Feature.ErrorPrototypeStack;
+const HYDRATION_GLOBAL = "_$HY.r";
 function createSerializer(options) {
   return new seroval.Serializer({
     ...options,
@@ -99,16 +158,19 @@ function createHydrationSerializer({
 function getLocalHeaderScript(id) {
   return seroval.getCrossReferenceHeader(id) + ";";
 }
-seroval.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]);
 }
@@ -195,9 +257,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 = {};
@@ -235,6 +306,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_:.-]*$/;
@@ -306,7 +389,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]]
@@ -496,7 +578,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);
@@ -548,7 +629,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;
     }
@@ -589,7 +669,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);
@@ -651,7 +730,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];
@@ -659,7 +737,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);
@@ -685,12 +762,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({
@@ -772,7 +847,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];
@@ -790,7 +864,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];
@@ -823,7 +896,6 @@ function renderHeadTagMarkup(tag, props, identity, nonce) {
 function useHead(tags) {
   const ctx = solidJs.sharedConfig.context;
   if (!ctx || !ctx.registerHeadTags) {
-    console.warn("useHead() called outside of a server render; registration ignored.");
     return;
   }
   ctx.registerHeadTags(tags);
@@ -893,7 +965,7 @@ function renderToString(code, options = {}) {
   }, {
     id: renderId
   });
-  serializeFragmentAssets("", tracking.boundaryModules, solidJs.sharedConfig.context);
+  serializeFragmentAssets("", tracking.boundaryModules, solidJs.sharedConfig.context, renderId);
   solidJs.sharedConfig.context.noHydrate = true;
   serializer.close();
   const head = renderShellHead(headRegistry, nonce, null);
@@ -927,6 +999,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;
@@ -1023,12 +1101,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();
@@ -1089,6 +1175,7 @@ function renderToStream(code, options = {}) {
   solidJs.sharedConfig.context = context = {
     async: true,
     nonce,
+    live: {},
     registerHeadTags(tags) {
       registerHeadTags(headRegistry, context, tracking,
       (markup, gateEntry) => {
@@ -1125,6 +1212,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}-->`;
@@ -1233,6 +1330,7 @@ function renderToStream(code, options = {}) {
     }
   };
   applyAssetTracking(context, tracking, manifest, noScripts);
+  context.failRender = failRender;
   registerEntryAssets(manifest);
   let html = solidJs.createRoot(d => {
     dispose = d;
@@ -1345,7 +1443,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();
@@ -1402,7 +1505,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);
             });
           });
@@ -1417,7 +1525,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);
@@ -1462,9 +1578,27 @@ function ssrGroup(fn, n) {
 function buildAsyncWrap(err, node) {
   const p = solidJs.ssrHandleError(err);
   if (!p) return null;
+  if (node.$rw) return {
+    fn: node,
+    p
+  };
   const owner = solidJs.getOwner();
+  const live = solidJs.sharedConfig.context && solidJs.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 = () => solidJs.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 ? () => solidJs.runWithOwner(owner, node) : node,
+    fn,
     p
   };
 }
@@ -1524,6 +1658,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 solidJs.creationStamp === "function" ? solidJs.creationStamp : () => 0;
+  const inScope = scoped && typeof solidJs.inServerComponentScope === "function" ? solidJs.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 = solidJs.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 ? solidJs.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 = solidJs.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 ? solidJs.runWithOwner(owner, run) : run();
+          } catch (err) {
+            if (solidJs.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 {
@@ -1534,13 +1988,54 @@ function ssr(t) {
   let lastGroup = null;
   let lastGroupVal = null;
   let lastGroupIdx = 0;
+  const live = solidJs.sharedConfig.context && solidJs.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;
@@ -1564,7 +2059,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("");
@@ -1574,6 +2076,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 {
@@ -1591,19 +2094,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") {
@@ -1619,6 +2170,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 {
@@ -1843,10 +2420,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);
@@ -1954,7 +2531,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;
@@ -1979,13 +2555,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 && solidJs.sharedConfig.context && solidJs.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) {
@@ -1997,16 +2579,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 = solidJs.sharedConfig.context && solidJs.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("");
+        }
       }
     }
   }
@@ -2039,7 +2627,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
@@ -2243,6 +2831,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(solidJs.getProjectionTrace);
 const isServer = true;
 const isDev = false;
 function dynamic(source) {
@@ -2308,18 +2897,39 @@ function clientOnly(_fn, _options = {}, moduleUrl) {
     return solidJs.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;
     solidJs.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);
     });
   }
 }
@@ -2328,16 +2938,39 @@ 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);
     solidJs.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);
     });
   }
 }
@@ -2426,10 +3059,12 @@ exports.assign = notSup;
 exports.claimElement = claimElement;
 exports.claimElementTree = claimElementTree;
 exports.className = notSup;
+exports.clearFlashCookie = clearFlashCookie;
 exports.clientOnly = clientOnly;
 exports.commitEventResponse = commitEventResponse;
 exports.commitResponseStub = commitResponseStub;
 exports.composeMiddleware = composeMiddleware;
+exports.createLiveHoles = createLiveHoles;
 exports.createRequestEvent = createRequestEvent;
 exports.createResponseStub = createResponseStub;
 exports.createSSRResponse = createSSRResponse;
@@ -2446,6 +3081,9 @@ exports.getNextElement = notSup;
 exports.getNextMarker = notSup;
 exports.getNextMatch = notSup;
 exports.getRequestEvent = getRequestEvent;
+exports.getServerFunctionMetadata = getServerFunctionMetadata;
+exports.getServerFunctionRPC = getServerFunctionRPC;
+exports.hasFlashCookie = hasFlashCookie;
 exports.httpHeader = httpHeader;
 exports.httpStatus = httpStatus;
 exports.hydrate = notSup;
@@ -2455,6 +3093,7 @@ exports.isHref = isHref;
 exports.isResponseEnvelope = isResponseEnvelope;
 exports.isSafeError = isSafeError;
 exports.isServer = isServer;
+exports.isServerFunction = isServerFunction;
 exports.markSafeError = markSafeError;
 exports.memo = memo;
 exports.parseCookieHeader = parseCookieHeader;