@solidjs/web 2.0.0-beta.31 → 2.0.0-beta.33

package/frames/dist/server.js

@@ -1,20 +1,130 @@
-import { runWithOwner, createOwner, sharedConfig, createRoot, ssrHandleError, getOwner, NoHydration, runInServerComponentScope, Hydration } from 'solid-js';
-import { toCrossJSONStream, Feature, Serializer, getCrossReferenceHeader, createPlugin } from 'seroval';
+import { createMemo, runWithOwner, createOwner, sharedConfig, createRoot, ssrHandleError, getOwner, inServerComponentScope, creationStamp, NoHydration, runInServerComponentScope, Hydration, getProjectionTrace } from 'solid-js';
+import { Feature, toCrossJSONStream, Serializer, getCrossReferenceHeader } from 'seroval';
 import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
 
+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;
+}
+function isContainerTraced(value) {
+  const resolve = state.resolveTrace;
+  return !!(resolve && value && typeof value === "object" && resolve(value));
+}
+const TRACE = Symbol.for("dom-expressions.container-trace");
+function envelopeContainerTraces(value) {
+  if (!state.resolveTrace || value == null || typeof value !== "object") return value;
+  const trace = state.resolveTrace(value);
+  if (trace) return {
+    [TRACE]: trace
+  };
+  if (Array.isArray(value)) {
+    let out = value;
+    for (let i = 0; i < value.length; i++) {
+      const next = envelopeContainerTraces(value[i]);
+      if (next !== value[i]) {
+        if (out === value) out = value.slice();
+        out[i] = next;
+      }
+    }
+    return out;
+  }
+  if (Object.getPrototypeOf(value) === Object.prototype) {
+    let out = value;
+    for (const key of Object.keys(value)) {
+      const next = envelopeContainerTraces(value[key]);
+      if (next !== value[key]) {
+        if (out === value) out = {
+          ...value
+        };
+        out[key] = next;
+      }
+    }
+    return out;
+  }
+  return value;
+}
+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 runWithHydrationScope = (id, fn) => runWithOwner(createOwner({
   id
 }), fn);
+const ssrAsyncValue = value => createMemo(() => value, {
+  serialize: false
+});
 
-const DEFAULT_DISABLED_FEATURES = Feature.AggregateError | Feature.BigIntTypedArray;
-const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : Feature.ErrorPrototypeStack;
-const HYDRATION_GLOBAL = "_$HY.r";
 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];
 }
+const JSON_CODEC_DISABLED_FEATURES = Feature.RegExp;
+const JSON_CODEC_DEPTH_LIMIT = 64;
+function resolveCodecOptions({
+  plugins,
+  disabledFeatures,
+  depthLimit
+} = {}) {
+  return {
+    plugins: resolveSerializerPlugins(plugins),
+    disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
+    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
+  };
+}
+
+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,
@@ -41,34 +151,6 @@ function createHydrationSerializer({
 function getLocalHeaderScript(id) {
   return getCrossReferenceHeader(id) + ";";
 }
-const JSON_CODEC_DISABLED_FEATURES = Feature.RegExp;
-const JSON_CODEC_DEPTH_LIMIT = 64;
-function resolveCodecOptions({
-  plugins,
-  disabledFeatures,
-  depthLimit
-} = {}) {
-  return {
-    plugins: resolveSerializerPlugins(plugins),
-    disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
-    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
-  };
-}
-function serializeJSON(value, {
-  onParse,
-  onDone,
-  onError,
-  ...codecOptions
-}) {
-  const resolved = resolveCodecOptions(codecOptions);
-  return toCrossJSONStream(value, {
-    onParse,
-    onDone,
-    onError,
-    ...resolved,
-    disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures()
-  });
-}
 function createJSONSerializer({
   onData,
   onDone,
@@ -135,6 +217,146 @@ function createJSONSerializer({
   };
 }
 
+const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
+function isResponseEnvelope(value) {
+  return !!(value && typeof value === "object" && value[ENVELOPE]);
+}
+const REVALIDATE_HEADER = "X-Revalidate";
+
+function frameAddress(id, args) {
+  return args && args.length ? id + ":" + hashArguments(args) : id;
+}
+function hashArguments(args) {
+  let hash = 0;
+  const text = stableString(args);
+  for (let i = 0; i < text.length; i++) {
+    hash = (hash << 5) - hash + text.charCodeAt(i);
+    hash |= 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+function stableString(value, seen) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "bigint" ? value + "n" : String(value);
+  }
+  if (value instanceof Date) return "Date:" + value.getTime();
+  seen || (seen = new Set());
+  if (seen.has(value)) return "~";
+  seen.add(value);
+  if (value instanceof Map) {
+    const entries = [];
+    for (const [k, v] of value) {
+      entries.push(stableString(k, seen) + "=>" + stableString(v, seen));
+    }
+    return "Map{" + entries.sort().join(",") + "}";
+  }
+  if (value instanceof Set) {
+    const members = [];
+    for (const v of value) members.push(stableString(v, seen));
+    return "Set{" + members.sort().join(",") + "}";
+  }
+  if (Array.isArray(value)) {
+    let out = "[";
+    for (let i = 0; i < value.length; i++) out += (i ? "," : "") + stableString(value[i], seen);
+    return out + "]";
+  }
+  const keys = Object.keys(value).sort();
+  let out = "{";
+  for (let i = 0; i < keys.length; i++) {
+    out += (i ? "," : "") + keys[i] + ":" + stableString(value[keys[i]], seen);
+  }
+  return out + "}";
+}
+const ERROR_HEADER = "X-Server-Function-Error";
+const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
+function createChunk(data) {
+  const encoder = new TextEncoder();
+  const encodeData = encoder.encode(data);
+  const bytes = encodeData.length;
+  const chunk = new Uint8Array(12 + bytes);
+  chunk.set(encoder.encode(`;0x${bytes.toString(16).padStart(8, "0")};`));
+  chunk.set(encodeData, 12);
+  return chunk;
+}
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = new Uint8Array(0);
+    this.done = false;
+  }
+  async readChunk() {
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+      newBuffer.set(this.buffer);
+      newBuffer.set(chunk.value, this.buffer.length);
+      this.buffer = newBuffer;
+    } else {
+      this.done = true;
+    }
+  }
+  async next() {
+    while (this.buffer.length < 12) {
+      if (this.done) {
+        if (this.buffer.length === 0) return {
+          done: true,
+          value: undefined
+        };
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const decoder = new TextDecoder();
+    const bytes = Number.parseInt(decoder.decode(this.buffer.subarray(1, 11)), 16);
+    if (Number.isNaN(bytes)) {
+      throw new Error("Malformed server function stream.");
+    }
+    while (bytes > this.buffer.length - 12) {
+      if (this.done) {
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const partial = decoder.decode(this.buffer.subarray(12, 12 + bytes));
+    this.buffer = this.buffer.subarray(12 + bytes);
+    return {
+      done: false,
+      value: partial
+    };
+  }
+  async drain(interpret) {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
+      interpret(result.value);
+    }
+  }
+}
+function serializeStream(value, codecOptions) {
+  return new ReadableStream({
+    async start(controller) {
+      const {
+        serializeJSON
+      } = await import('@solidjs/web/serialization');
+      serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          controller.close();
+        },
+        onError(error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+
 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"]);
@@ -205,7 +427,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]]
@@ -375,7 +596,8 @@ function createHeadRegistry() {
     resources: new Set(),
     eagerHtml: "",
     flushed: null,
-    shellFlushed: false
+    shellFlushed: false,
+    parkedResources: []
   };
 }
 function registerHeadTags(registry, context, tracking, emitResource, nonce, tags) {
@@ -389,14 +611,24 @@ function registerHeadTags(registry, context, tracking, emitResource, nonce, tags
     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)) {
-      console.warn(`useHead: ignoring non-head tag`, desc);
       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 {
@@ -413,6 +645,51 @@ function registerHeadTags(registry, context, tracking, emitResource, nonce, tags
     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 {
@@ -420,7 +697,16 @@ function emitHeadResource(registry, context, tracking, emitResource, nonce, desc
       rel
     } : undefined);
   } catch (err) {
-    console.warn(`useHead: error evaluating resource tag props`, 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);
@@ -482,7 +768,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];
@@ -490,7 +775,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);
@@ -516,12 +800,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({
@@ -603,7 +885,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];
@@ -621,7 +902,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];
@@ -681,6 +961,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;
@@ -762,7 +1048,7 @@ function renderToStream(code, options = {}) {
       }
     },
     shell(shellHtml, meta) {
-      buffer.write(assembleDocument(shellHtml, meta.assets, meta.preloads, meta.inlineStyles, meta.tasks.length ? meta.tasks : "", nonce, meta.head, onHead));
+      buffer.write(assembleDocument(shellHtml, meta.preloads, meta.inlineStyles, meta.tasks.length ? meta.tasks : "", nonce, meta.head, onHead));
     },
     ...options.sink
   };
@@ -779,10 +1065,18 @@ function renderToStream(code, options = {}) {
     rootAssetsSerialized = true;
     serializeFragmentAssets("", tracking.boundaryModules, context);
   };
+  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();
@@ -842,8 +1136,8 @@ function renderToStream(code, options = {}) {
   };
   sharedConfig.context = context = {
     async: true,
-    assets: [],
     nonce,
+    live: {},
     registerHeadTags(tags) {
       registerHeadTags(headRegistry, context, tracking,
       (markup, gateEntry) => {
@@ -880,6 +1174,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}-->`;
@@ -988,6 +1292,7 @@ function renderToStream(code, options = {}) {
     }
   };
   applyAssetTracking(context, tracking, manifest, noScripts);
+  context.failRender = failRender;
   registerEntryAssets(manifest);
   let html = createRoot(d => {
     dispose = d;
@@ -1044,7 +1349,7 @@ function renderToStream(code, options = {}) {
     if (shellCompleted) return;
     sharedConfig.context = context;
     if (!resolveRootHoles()) return;
-    const assetsHtml = resolveAssetsHtml(context.assets);
+    if (!headShellReady(headRegistry, p => blockingPromises.add(p))) return;
     headStyles = new Set();
     for (const url of tracking.emittedAssets) {
       if (isCssUrl(url)) headStyles.add(url);
@@ -1052,7 +1357,6 @@ function renderToStream(code, options = {}) {
     serializeRootAssets();
     const head = renderShellHead(headRegistry, nonce, k => registry.has(k));
     sink.shell(html, {
-      assets: assetsHtml,
       preloads: tracking.emittedAssets,
       inlineStyles: tracking.inlineStyles,
       tasks,
@@ -1101,7 +1405,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();
@@ -1142,27 +1451,35 @@ function renderToStream(code, options = {}) {
     return p;
   };
   return {
-    then(fn) {
-      function complete() {
-        dispose();
-        fn(tmp);
-      }
-      if (onCompleteAll) {
-        let ogComplete = onCompleteAll;
-        onCompleteAll = options => {
-          ogComplete(options);
-          complete();
-        };
-      } else onCompleteAll = complete;
-      function flush() {
-        allSettled(blockingPromises).then(() => {
-          scheduleFlush(() => {
-            if (!resolveRootHoles()) return flush();
-            queue(flushEnd);
+    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();
+        }
+        flush();
+      });
+      return p.then(onFulfilled, onRejected);
     },
     pipe(w) {
       claimConsumer("pipe");
@@ -1170,7 +1487,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);
@@ -1202,9 +1527,27 @@ function renderToStream(code, options = {}) {
 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
   };
 }
@@ -1264,6 +1607,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 {
@@ -1274,13 +1937,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;
@@ -1304,7 +2008,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("");
@@ -1314,6 +2025,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 {
@@ -1331,19 +2043,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") {
@@ -1359,6 +2119,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 {
@@ -1447,17 +2233,11 @@ function allSettled(promises) {
     return;
   });
 }
-function resolveAssetsHtml(assets) {
-  if (!assets || !assets.length) return "";
-  let out = "";
-  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
-  return out;
-}
-function assembleDocument(html, assetsHtml, emittedAssets, inlineStyles, scripts, nonce, headTags, onHead) {
+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 && !assetsHtml && !headTagsHtml && !headPrelude && !(emittedAssets && emittedAssets.size) && !(inlineStyles && inlineStyles.size)) {
+  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);
@@ -1472,13 +2252,13 @@ function assembleDocument(html, assetsHtml, emittedAssets, inlineStyles, scripts
   const headIdx = html.indexOf("</head>");
   if (headIdx === -1) {
     if (onHead) {
-      onHead(headPrelude + headTagsHtml + (assetsHtml || "") + renderHeadAssets(emittedAssets, inlineStyles, nonce));
+      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 + (assetsHtml || "") + renderHeadAssets(emittedAssets, inlineStyles, nonce);
+  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;
@@ -1597,7 +2377,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;
@@ -1622,13 +2401,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) {
@@ -1640,16 +2425,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("");
+        }
       }
     }
   }
@@ -1660,142 +2451,7 @@ function resolveSSRSync(node) {
   if (!res.h.length) return res.t[0];
   throw new Error("This value cannot be rendered synchronously. Are you missing a boundary?");
 }
-
-function frameAddress(id, args) {
-  return args && args.length ? id + ":" + hashArguments(args) : id;
-}
-function hashArguments(args) {
-  let hash = 0;
-  const text = stableString(args);
-  for (let i = 0; i < text.length; i++) {
-    hash = (hash << 5) - hash + text.charCodeAt(i);
-    hash |= 0;
-  }
-  return (hash >>> 0).toString(36);
-}
-function stableString(value, seen) {
-  if (value === null || typeof value !== "object") {
-    return typeof value === "bigint" ? value + "n" : String(value);
-  }
-  if (value instanceof Date) return "Date:" + value.getTime();
-  seen || (seen = new Set());
-  if (seen.has(value)) return "~";
-  seen.add(value);
-  if (value instanceof Map) {
-    const entries = [];
-    for (const [k, v] of value) {
-      entries.push(stableString(k, seen) + "=>" + stableString(v, seen));
-    }
-    return "Map{" + entries.sort().join(",") + "}";
-  }
-  if (value instanceof Set) {
-    const members = [];
-    for (const v of value) members.push(stableString(v, seen));
-    return "Set{" + members.sort().join(",") + "}";
-  }
-  if (Array.isArray(value)) {
-    let out = "[";
-    for (let i = 0; i < value.length; i++) out += (i ? "," : "") + stableString(value[i], seen);
-    return out + "]";
-  }
-  const keys = Object.keys(value).sort();
-  let out = "{";
-  for (let i = 0; i < keys.length; i++) {
-    out += (i ? "," : "") + keys[i] + ":" + stableString(value[keys[i]], seen);
-  }
-  return out + "}";
-}
-const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
-function createChunk(data) {
-  const encodeData = new TextEncoder().encode(data);
-  const bytes = encodeData.length;
-  const baseHex = bytes.toString(16);
-  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex;
-  const head = new TextEncoder().encode(`;0x${totalHex};`);
-  const chunk = new Uint8Array(12 + bytes);
-  chunk.set(head);
-  chunk.set(encodeData, 12);
-  return chunk;
-}
-class ChunkReader {
-  constructor(stream) {
-    this.reader = stream.getReader();
-    this.buffer = new Uint8Array(0);
-    this.done = false;
-  }
-  async readChunk() {
-    const chunk = await this.reader.read();
-    if (!chunk.done) {
-      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
-      newBuffer.set(this.buffer);
-      newBuffer.set(chunk.value, this.buffer.length);
-      this.buffer = newBuffer;
-    } else {
-      this.done = true;
-    }
-  }
-  async next() {
-    while (this.buffer.length < 12) {
-      if (this.done) {
-        if (this.buffer.length === 0) return {
-          done: true,
-          value: undefined
-        };
-        throw new Error("Malformed server function stream.");
-      }
-      await this.readChunk();
-    }
-    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
-    const bytes = Number.parseInt(head, 16);
-    if (Number.isNaN(bytes)) {
-      throw new Error("Malformed server function stream.");
-    }
-    while (bytes > this.buffer.length - 12) {
-      if (this.done) {
-        throw new Error("Malformed server function stream.");
-      }
-      await this.readChunk();
-    }
-    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
-    this.buffer = this.buffer.subarray(12 + bytes);
-    return {
-      done: false,
-      value: partial
-    };
-  }
-  async drain(interpret) {
-    while (true) {
-      const result = await this.next();
-      if (result.done) {
-        break;
-      }
-      interpret(result.value);
-    }
-  }
-}
-function serializeStream(value, codecOptions) {
-  return new ReadableStream({
-    start(controller) {
-      serializeJSON(value, {
-        ...codecOptions,
-        onParse(node) {
-          controller.enqueue(createChunk(JSON.stringify(node)));
-        },
-        onDone() {
-          controller.close();
-        },
-        onError(error) {
-          controller.error(error);
-        }
-      });
-    }
-  });
-}
-
-const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
-function isResponseEnvelope(value) {
-  return !!(value && typeof value === "object" && value[ENVELOPE]);
-}
+/*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, "Location"].map(header => header.toLowerCase()));
 
 const INVOCATIONS = new WeakMap();
 function getEventServerFunctionInvocation(event) {
@@ -1819,7 +2475,7 @@ function parseServerComponent(value, ctx) {
     address: ctx.parse(value[SERVER_COMPONENT_ADDRESS])
   };
 }
-const ServerComponentPlugin = /*#__PURE__*/createPlugin({
+const ServerComponentPlugin = {
   tag: "dom-expressions/server-component",
   test(value) {
     return typeof value === "function" && SERVER_COMPONENT in value;
@@ -1843,18 +2499,17 @@ const ServerComponentPlugin = /*#__PURE__*/createPlugin({
     ctx.deserialize(node.address);
     return globalThis._$SC.r(id);
   }
-});
+};
 function flightCodec(codec) {
   const plugins = codec && codec.plugins || [];
-  for (const plugin of plugins) {
-    if (plugin && plugin.tag === "dom-expressions/server-component") return codec;
-  }
+  if (plugins.some(plugin => plugin && plugin.tag === ServerComponentPlugin.tag)) return codec;
   return {
     ...codec,
     plugins: [...plugins, ServerComponentPlugin]
   };
 }
 
+const scopeStamp = typeof creationStamp === "function" ? creationStamp : () => 0;
 function serverOwned(render) {
   return NoHydration ? NoHydration({
     get children() {
@@ -1879,6 +2534,29 @@ function createFrameSink(emit, frame) {
     version
   } = frame;
   const styledKeys = new Set();
+  const bindings = new Map();
+  const sweepMinted = new Set();
+  const argRefVersions = new Map();
+  let sweepScheduled = false;
+  let closed = false;
+  let epoch = 0;
+  const sweep = () => {
+    epoch++;
+    for (const b of [...bindings.values()]) {
+      try {
+        b.sweep();
+      } catch (_) {
+      }
+    }
+  };
+  const scheduleSweep = () => {
+    if (closed || sweepScheduled || !bindings.size) return;
+    sweepScheduled = true;
+    queueMicrotask(() => {
+      sweepScheduled = false;
+      if (!closed) sweep();
+    });
+  };
   const regionKeys = new Map();
   const frameOf = key => regionKeys.get(key) || id;
   return {
@@ -1920,6 +2598,7 @@ function createFrameSink(emit, frame) {
           version,
           payload: record
         });
+        scheduleSweep();
       } else {
         emit({
           type: "data",
@@ -1929,6 +2608,7 @@ function createFrameSink(emit, frame) {
           node: record.node,
           initial: record.initial
         });
+        if (!sweepMinted.has(record.key)) scheduleSweep();
       }
     },
     fragment(key, value, meta = {}) {
@@ -1965,6 +2645,7 @@ function createFrameSink(emit, frame) {
         key,
         html: value
       });
+      scheduleSweep();
       if (meta.error) {
         emit({
           type: "error",
@@ -2019,6 +2700,8 @@ function createFrameSink(emit, frame) {
       });
     },
     end() {
+      if (bindings.size) sweep();
+      closed = true;
       emit({
         type: "complete",
         id,
@@ -2050,6 +2733,44 @@ function createFrameSink(emit, frame) {
         version,
         html
       });
+    },
+    hole(key, html) {
+      emit({
+        type: "hole",
+        id,
+        version,
+        key,
+        html
+      });
+    },
+    attr(key, attrs, removed) {
+      const chunk = {
+        type: "attr",
+        id,
+        version,
+        key,
+        attrs
+      };
+      if (removed && removed.length) chunk.removed = removed;
+      emit(chunk);
+    },
+    openBinding(key, b) {
+      bindings.set(key, b);
+    },
+    closeBinding(key) {
+      bindings.delete(key);
+    },
+    mintRef(ref) {
+      sweepMinted.add(ref);
+    },
+    nextArgRef(ledgerKey) {
+      const n = (argRefVersions.get(ledgerKey) || 0) + 1;
+      argRefVersions.set(ledgerKey, n);
+      return n;
+    },
+    commit: scheduleSweep,
+    get epoch() {
+      return epoch;
     }
   };
 }
@@ -2059,7 +2780,15 @@ function renderToFrameStream(code, options = {}) {
 function renderServerComponent(component, options = {}) {
   return frameStream((sink, frame) => {
     const props = createSlotProps(sink, frame);
-    return () => serverComponentScope(() => component(props));
+    return () => {
+      const ctx = sharedConfig.context;
+      if (ctx) {
+        ctx.commit = sink.commit;
+        ctx.commitEpoch = () => sink.epoch;
+        ctx.liveHoles = createLiveHoles(sink);
+      }
+      return serverComponentScope(() => component(props));
+    };
   }, options);
 }
 function frameStream(makeCode, options) {
@@ -2117,7 +2846,8 @@ function frameStream(makeCode, options) {
 }
 function slotRange(occurrence) {
   return {
-    t: `<!--slot:${occurrence}:start--><!--slot:${occurrence}:end-->`
+    t: `<!--slot:${occurrence}:start--><!--slot:${occurrence}:end-->`,
+    $slot: true
   };
 }
 const OCCURRENCE_UNSAFE = /[^A-Za-z0-9_.-]/g;
@@ -2136,14 +2866,57 @@ function occurrenceId(prop, raw, counts) {
   counts[prop] = n + 1;
   return `${prop}#${n}`;
 }
+function isAsyncValue(v) {
+  return !!v && typeof v === "object" && (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function");
+}
+function tapFirstYield(iterable) {
+  const iter = iterable[Symbol.asyncIterator]();
+  const firstStep = Promise.resolve(iter.next());
+  return {
+    first: firstStep.then(r => r.done ? undefined : r.value),
+    rest: {
+      [Symbol.asyncIterator]() {
+        let replayed = false;
+        return {
+          next: () => {
+            if (!replayed) {
+              replayed = true;
+              return firstStep;
+            }
+            return iter.next();
+          },
+          return: v => iter.return ? iter.return(v) : Promise.resolve({
+            done: true,
+            value: v
+          }),
+          throw: e => iter.throw ? iter.throw(e) : Promise.reject(e)
+        };
+      }
+    }
+  };
+}
+function suppressedFill(render) {
+  const live = sharedConfig.context && sharedConfig.context.liveHoles;
+  if (!live) return render();
+  live.suppressed++;
+  try {
+    return render();
+  } finally {
+    live.suppressed--;
+  }
+}
 function createDocumentSlotProps(clientProps, frameId) {
   const counts = Object.create(null);
   const getters = new Map();
-  const range = (occurrence, content) => [{
-    t: `<!--slot:${occurrence}:start-->`
-  }, content, {
-    t: `<!--slot:${occurrence}:end-->`
-  }];
+  const range = (occurrence, content) => {
+    const r = [{
+      t: `<!--slot:${occurrence}:start-->`
+    }, content, {
+      t: `<!--slot:${occurrence}:end-->`
+    }];
+    r.$slot = true;
+    return r;
+  };
   const zoneOwner = getOwner ? getOwner() : null;
   const scoped = (occurrence, render) => {
     const id = `sc-${frameId}-${occurrence}-`;
@@ -2166,27 +2939,68 @@ function createDocumentSlotProps(clientProps, frameId) {
       if (!fn) {
         fn = (...callArgs) => {
           if (callArgs.length === 0 || callArgs[0] === undefined) {
-            return scoped(prop, () => {
+            return suppressedFill(() => scoped(prop, () => {
               const value = clientProps[prop];
               return range(prop, typeof value === "function" ? value() : value);
-            });
+            }));
           }
           const raw = callArgs[0];
           const occurrence = occurrenceId(prop, raw, counts);
           const slot = clientProps[prop];
           if (typeof slot !== "function") return range(occurrence, undefined);
           const resolved = {};
+          const liveArgs = sharedConfig.context && sharedConfig.context.live && sharedConfig.context.live.args;
           const vals = {};
+          const evals = {};
+          const states = {};
+          const minted = {};
           for (const key of Object.keys(raw)) {
             if (key === "$key") continue;
-            let value = raw[key];
-            for (let d = 0; typeof value === "function" && d < 16; d++) value = value();
+            const desc = Object.getOwnPropertyDescriptor(raw, key);
+            let evaluate = null;
+            let value;
+            if (desc.get) {
+              const get = desc.get;
+              evaluate = () => unwrapThunks(get.call(raw));
+            } else {
+              value = desc.value;
+              if (typeof value === "function") {
+                const fn = value;
+                evaluate = () => unwrapThunks(fn);
+              }
+            }
+            if (evaluate) {
+              evals[key] = evaluate;
+              const stampBefore = scopeStamp();
+              try {
+                value = evaluate();
+                states[key] = {
+                  settled: true,
+                  last: value
+                };
+              } catch (err) {
+                const blocked = ssrHandleError && ssrHandleError(err);
+                if (!blocked) throw err;
+                const state = states[key] = {
+                  settled: false,
+                  last: undefined
+                };
+                value = retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
+                  state.settled = true;
+                  state.last = v;
+                  if (liveArgs) liveArgs.commit();
+                });
+              }
+              if (scopeStamp() !== stampBefore) minted[key] = true;
+            }
             vals[key] = value;
           }
           const regions = [];
           for (const key of Object.keys(vals)) {
             const value = vals[key];
-            if (isServerContent(value)) {
+            if (isContainerTraced(value)) {
+              resolved[key] = value;
+            } else if (isServerContent(value)) {
               const childId = `${frameId}.${occurrence}.${key}`;
               const region = {
                 key,
@@ -2205,11 +3019,27 @@ function createDocumentSlotProps(clientProps, frameId) {
                   t: FRAME_ELEMENT_CLOSE
                 }];
               };
+            } else if (ssrAsyncValue && isAsyncValue(value)) {
+              let readable = value;
+              if (typeof value.then !== "function") {
+                const {
+                  first,
+                  rest
+                } = tapFirstYield(value);
+                readable = first;
+                vals[key] = rest;
+              }
+              const read = ssrAsyncValue(readable);
+              Object.defineProperty(resolved, key, {
+                get: read,
+                enumerable: true,
+                configurable: true
+              });
             } else {
               resolved[key] = value;
             }
           }
-          const out = scoped(occurrence, () => range(occurrence, slot(resolved)));
+          const out = suppressedFill(() => scoped(occurrence, () => range(occurrence, slot(resolved))));
           const unused = regions.filter(r => !r.used);
           if (sharedConfig.context) {
             const args = {};
@@ -2222,17 +3052,33 @@ function createDocumentSlotProps(clientProps, frameId) {
                 };
                 continue;
               }
-              if (isServerContent(value)) continue;
-              args[key] = value;
+              if (!isContainerTraced(value) && isServerContent(value)) continue;
+              args[key] = envelopeContainerTraces(value);
             }
-            sharedConfig.context.serialize(`sc:slot:${frameId}:${occurrence}`, args);
+            sharedConfig.context.serialize(`sc:slot:${frameId}:${occurrence}`, {
+              ...args
+            });
             for (const region of unused) {
               region.locked = true;
               sharedConfig.context.serialize(`sc:region:${region.childId}`, resolveRegionHtml(sharedConfig.context, region.value));
             }
+            if (liveArgs) {
+              for (const key of Object.keys(evals)) {
+                if (regions.some(r => r.key === key)) continue;
+                if (minted[key]) continue;
+                const ledgerKey = `${frameId}:${occurrence}:${key}`;
+                openArgBinding(liveArgs, ledgerKey, occurrence, key, evals[key], states[key], value => {
+                  args[key] = envelopeContainerTraces(value);
+                  liveArgs.slot(frameId, occurrence, {
+                    ...args
+                  });
+                });
+              }
+            }
           }
           return out;
         };
+        fn.$lhSkip = true;
         getters.set(prop, fn);
       }
       return fn;
@@ -2246,6 +3092,113 @@ function frameElementOpen(id) {
   return `<${FRAME_TAG} ${FRAME_ID_ATTR}="${escaped}" style="display:contents">`;
 }
 const FRAME_ELEMENT_CLOSE = `</${FRAME_TAG}>`;
+function armDocumentLiveHoles(ctx) {
+  if (!ctx || ctx.liveHoles !== undefined) return;
+  const live = ctx.live;
+  if (live && live.holes !== undefined) {
+    ctx.liveHoles = live.holes;
+    if (live.holes) {
+      ctx.commit = live.commit;
+      ctx.commitEpoch = live.commitEpoch;
+    }
+    return;
+  }
+  if (!live || !ctx.async || ctx.noHydrate || !ctx.serialize || typeof ReadableStream !== "function") {
+    ctx.liveHoles = null;
+    if (live) live.holes = null;
+    return;
+  }
+  const bindings = new Map();
+  let epoch = 0;
+  let sweepScheduled = false;
+  let closed = false;
+  const sweep = () => {
+    epoch++;
+    for (const b of [...bindings.values()]) {
+      try {
+        b.sweep();
+      } catch (_) {
+      }
+    }
+  };
+  const scheduleSweep = () => {
+    if (closed || sweepScheduled || !bindings.size) return;
+    sweepScheduled = true;
+    queueMicrotask(() => {
+      sweepScheduled = false;
+      if (!closed) sweep();
+    });
+  };
+  let channel;
+  ctx.serialize("sc:live", new ReadableStream({
+    start(c) {
+      channel = c;
+    }
+  }));
+  const push = op => {
+    if (!closed) channel.enqueue(op);
+  };
+  ctx.liveHoles = live.holes = createLiveHoles({
+    openBinding(key, b) {
+      bindings.set(key, b);
+    },
+    closeBinding(key) {
+      bindings.delete(key);
+    },
+    hole(key, html) {
+      push({
+        type: "hole",
+        key,
+        html
+      });
+    },
+    attr(key, attrs, removed) {
+      const op = {
+        type: "attr",
+        key,
+        attrs
+      };
+      if (removed && removed.length) op.removed = removed;
+      push(op);
+    },
+    error(key, error) {
+      push({
+        type: "error",
+        key,
+        error
+      });
+    },
+    commit: scheduleSweep,
+    get epoch() {
+      return epoch;
+    }
+  }, true);
+  ctx.commit = live.commit = scheduleSweep;
+  ctx.commitEpoch = live.commitEpoch = () => epoch;
+  live.args = {
+    openBinding(key, b) {
+      bindings.set(key, b);
+    },
+    closeBinding(key) {
+      bindings.delete(key);
+    },
+    slot(fid, occurrence, args) {
+      push({
+        type: "slot",
+        fid,
+        key: occurrence,
+        args
+      });
+    },
+    commit: scheduleSweep
+  };
+  live.end = () => {
+    if (closed) return;
+    if (bindings.size) sweep();
+    closed = true;
+    channel.close();
+  };
+}
 function frameTransformDirectResult(value, {
   id,
   args
@@ -2256,6 +3209,7 @@ function frameTransformDirectResult(value, {
     t: frameElementOpen(id)
   },
   serverOwned(() => {
+    armDocumentLiveHoles(sharedConfig.context);
     const slotProps = createDocumentSlotProps(props, id);
     return serverComponentScope(() => component(slotProps));
   }), {
@@ -2292,6 +3246,76 @@ function isServerContent(value) {
   }
   return false;
 }
+function unwrapThunks(value) {
+  for (let d = 0; typeof value === "function" && d < 16; d++) value = value();
+  return value;
+}
+function contentArgError(key, occurrence) {
+  return new Error("Async slot arg resolved to JSX (arg '" + key + "' of " + occurrence + "). Async args must resolve to serializable values; render async content through a boundary instead.");
+}
+function retryArgUntilSettled(evaluate, blocked, key, occurrence, onSettle) {
+  const owner = getOwner();
+  return new Promise((resolve, reject) => {
+    const retry = () => {
+      try {
+        const value = owner ? runWithOwner(owner, evaluate) : evaluate();
+        if (isServerContent(value)) {
+          reject(contentArgError(key, occurrence));
+          return;
+        }
+        if (onSettle) onSettle(value);
+        resolve(value);
+      } catch (err) {
+        const next = ssrHandleError && ssrHandleError(err);
+        if (next) next.then(retry, retry);else reject(err);
+      }
+    };
+    blocked.then(retry, retry);
+  });
+}
+function openArgBinding(sink, ledgerKey, occurrence, key, evaluate, state, emit) {
+  const owner = getOwner();
+  sink.openBinding(ledgerKey, {
+    sweep() {
+      if (!state.settled) return;
+      let value;
+      const stampBefore = scopeStamp();
+      try {
+        value = owner ? runWithOwner(owner, evaluate) : evaluate();
+      } catch (err) {
+        const blocked = ssrHandleError && ssrHandleError(err);
+        if (!blocked) {
+          sink.closeBinding(ledgerKey);
+          emit(Promise.reject(err instanceof Error ? err : new Error(String(err))));
+          return;
+        }
+        if (scopeStamp() !== stampBefore) {
+          sink.closeBinding(ledgerKey);
+          return;
+        }
+        state.settled = false;
+        emit(retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
+          state.settled = true;
+          state.last = v;
+          sink.commit();
+        }));
+        return;
+      }
+      if (scopeStamp() !== stampBefore) {
+        sink.closeBinding(ledgerKey);
+        return;
+      }
+      if (value === state.last) return;
+      state.last = value;
+      if (isServerContent(value)) {
+        sink.closeBinding(ledgerKey);
+        emit(Promise.reject(contentArgError(key, occurrence)));
+        return;
+      }
+      emit(value);
+    }
+  });
+}
 function createSlotProps(sink, frame) {
   const counts = Object.create(null);
   const getters = new Map();
@@ -2308,9 +3332,21 @@ function createSlotProps(sink, frame) {
           if (callArgs.length === 0 || callArgs[0] === undefined) {
             return slotRange(prop);
           }
+          const live = sharedConfig.context && sharedConfig.context.liveHoles;
+          if (live) {
+            if (live.sweeping) {
+              live.gateHit = true;
+              return {
+                t: "",
+                $slot: true
+              };
+            }
+            live.recordStamp++;
+          }
           const raw = callArgs[0];
           const occurrence = occurrenceId(prop, raw, counts);
           const args = {};
+          const opened = [];
           for (const key of Object.keys(raw)) {
             if (key === "$key") continue;
             const childId = `${frame.id}.${occurrence}.${key}`;
@@ -2321,12 +3357,47 @@ function createSlotProps(sink, frame) {
               return origRegister.call(ctx, fragKey, fragOptions);
             };
             try {
-              let value = raw[key];
-              for (let d = 0; typeof value === "function" && d < 16; d++) value = value();
+              const desc = Object.getOwnPropertyDescriptor(raw, key);
+              let evaluate = null;
+              let value;
+              let state = null;
+              const stampBefore = scopeStamp();
+              try {
+                if (desc.get) {
+                  const get = desc.get;
+                  evaluate = () => unwrapThunks(get.call(raw));
+                  value = evaluate();
+                } else {
+                  value = desc.value;
+                  if (typeof value === "function") {
+                    const fn = value;
+                    evaluate = () => unwrapThunks(fn);
+                    value = evaluate();
+                  }
+                }
+              } catch (err) {
+                const blocked = ssrHandleError && ssrHandleError(err);
+                if (!blocked) throw err;
+                state = {
+                  settled: false,
+                  last: undefined
+                };
+                const pendingState = state;
+                value = retryArgUntilSettled(evaluate, blocked, key, occurrence, v => {
+                  pendingState.settled = true;
+                  pendingState.last = v;
+                  sink.commit();
+                });
+              }
+              const mintedEval = scopeStamp() !== stampBefore;
               const t = typeof value;
               if (value == null || t === "string" || t === "number" || t === "boolean") {
                 args[key] = value;
-              } else if (isServerContent(value)) {
+                if (evaluate) state = {
+                  settled: true,
+                  last: value
+                };
+              } else if (!isContainerTraced(value) && isServerContent(value)) {
                 const resolved = ctx.resolve(value);
                 if (resolved.h.length) {
                   throw new Error("Async server content in a slot arg needs a boundary (arg '" + key + "' of " + occurrence + "). Wrap the async read in a <Suspense>, or move it above the slot.");
@@ -2337,30 +3408,72 @@ function createSlotProps(sink, frame) {
                 };
               } else {
                 const ref = `arg:${occurrence}:${key}`;
-                ctx.serialize(ref, value);
+                ctx.serialize(ref, envelopeContainerTraces(value));
                 args[key] = {
                   $ref: ref
                 };
+                if (evaluate && !state) state = {
+                  settled: true,
+                  last: value
+                };
               }
+              if (evaluate && state && !mintedEval) opened.push({
+                key,
+                evaluate,
+                state
+              });
             } finally {
               ctx.registerFragment = origRegister;
             }
           }
-          sink.slot(occurrence, args);
+          sink.slot(occurrence, {
+            ...args
+          });
+          const ctx = sharedConfig.context;
+          for (const b of opened) {
+            const key = b.key;
+            const ledgerKey = `${occurrence}:${key}`;
+            openArgBinding(sink, ledgerKey, occurrence, key, b.evaluate, b.state, value => {
+              const t = typeof value;
+              if (value == null || t === "string" || t === "number" || t === "boolean") {
+                args[key] = value;
+              } else {
+                const ref = `arg:${occurrence}:${key}@${sink.nextArgRef(ledgerKey)}`;
+                sink.mintRef(ref);
+                ctx.serialize(ref, envelopeContainerTraces(value));
+                args[key] = {
+                  $ref: ref
+                };
+              }
+              sink.slot(occurrence, {
+                ...args
+              });
+            });
+          }
           return slotRange(occurrence);
         };
+        fn.$lhSkip = true;
         getters.set(prop, fn);
       }
       return fn;
     }
   });
 }
+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;
+}
 function serverComponentResponse(component, options = {}, init = {}) {
   const {
     id = "",
     version = 1
   } = options.frame || {};
-  const headers = new Headers(init.headers);
+  const headers = copyInitHeaders(init.headers);
   headers.set("Content-Type", "application/x-frame-stream");
   headers.set(FRAME_STREAM_HEADER, id);
   headers.set("X-Content-Raw", "1");
@@ -2371,16 +3484,27 @@ function serverComponentResponse(component, options = {}, init = {}) {
       version
     }
   });
+  let closed = false;
   const body = new ReadableStream({
     start(controller) {
       stream.pipe({
         write(chunk) {
-          controller.enqueue(createChunk(JSON.stringify(chunk)));
+          if (closed) return;
+          try {
+            controller.enqueue(createChunk(JSON.stringify(chunk)));
+          } catch (_) {
+            closed = true;
+          }
         },
         end() {
+          if (closed) return;
+          closed = true;
           controller.close();
         }
       });
+    },
+    cancel() {
+      closed = true;
     }
   });
   return new Response(body, {
@@ -2459,14 +3583,22 @@ function frameFlightResponse({
   codec
 }, init = {}) {
   const frames = primary ? [primary, ...regions] : regions;
-  const headers = new Headers(init.headers);
+  const headers = copyInitHeaders(init.headers);
   headers.set("Content-Type", "application/x-frame-stream");
   headers.set(FRAME_STREAM_HEADER, primary ? primary.id : "");
   headers.set("X-Content-Raw", "1");
   headers.set(SINGLE_FLIGHT_HEADER, "true");
+  let closed = false;
   const body = new ReadableStream({
     async start(controller) {
-      const write = chunk => controller.enqueue(createChunk(JSON.stringify(chunk)));
+      const write = chunk => {
+        if (closed) return;
+        try {
+          controller.enqueue(createChunk(JSON.stringify(chunk)));
+        } catch (_) {
+          closed = true;
+        }
+      };
       try {
         for (const {
           id,
@@ -2493,10 +3625,19 @@ function frameFlightResponse({
             });
           }
         }
-        controller.close();
+        if (!closed) {
+          closed = true;
+          controller.close();
+        }
       } catch (err) {
-        controller.error(err);
+        if (!closed) {
+          closed = true;
+          controller.error(err);
+        }
       }
+    },
+    cancel() {
+      closed = true;
     }
   });
   return new Response(body, {
@@ -2505,4 +3646,9 @@ function frameFlightResponse({
   });
 }
 
-export { FRAME_STREAM_HEADER, SERVER_COMPONENT_BOOTSTRAP, ServerComponentPlugin, createFrameSink, frameTransformDirectResult, frameTransformFlightResult, frameTransformResult, isFrameStreamResponse, renderServerComponent, renderToFrameStream, serverComponentResponse };
+setContainerTraceResolver(getProjectionTrace);
+function asyncArg(value) {
+  return value;
+}
+
+export { FRAME_STREAM_HEADER, SERVER_COMPONENT_BOOTSTRAP, ServerComponentPlugin, asyncArg, createFrameSink, frameTransformDirectResult, frameTransformFlightResult, frameTransformResult, isFrameStreamResponse, renderServerComponent, renderToFrameStream, serverComponentResponse };