@solidjs/web 2.0.0-rc.4 → 2.0.0-rc.6

package/frames/dist/server.cjs

@@ -101,6 +101,8 @@ const ContainerTracePlugin = {
   }
 };
 
+const COMPOSED_BODY_FRAMING = /*#__PURE__*/new Set(["content-length", "content-encoding", "transfer-encoding"]);
+
 setContainerTraceStreamMint(iterable => {
   const stream = seroval.createStream();
   (async () => {
@@ -125,23 +127,25 @@ const JSON_CODEC_DEPTH_LIMIT = 64;
 function resolveCodecOptions({
   plugins,
   disabledFeatures,
-  depthLimit
+  depthLimit,
+  serializeErrorStacks
 } = {}) {
   return {
     plugins: resolveSerializerPlugins(plugins),
     disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
-    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
+    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit,
+    serializeErrorStacks
   };
 }
 
 const DEFAULT_DISABLED_FEATURES = seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
-const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : seroval.Feature.ErrorPrototypeStack;
+const serializeOnlyDisabledFeatures = serializeErrorStacks => (serializeErrorStacks === undefined ? process.env.NODE_ENV === "development" : serializeErrorStacks) ? 0 : seroval.Feature.ErrorPrototypeStack;
 const HYDRATION_GLOBAL = "_$HY.r";
 function createSerializer(options) {
   return new seroval.Serializer({
     ...options,
     plugins: resolveSerializerPlugins(options.plugins),
-    disabledFeatures: (options.disabledFeatures === undefined ? DEFAULT_DISABLED_FEATURES : options.disabledFeatures) | serializeOnlyDisabledFeatures()
+    disabledFeatures: (options.disabledFeatures === undefined ? DEFAULT_DISABLED_FEATURES : options.disabledFeatures) | serializeOnlyDisabledFeatures(options.serializeErrorStacks)
   });
 }
 function createHydrationSerializer({
@@ -169,12 +173,14 @@ function createJSONSerializer({
   onError,
   plugins,
   disabledFeatures,
-  depthLimit
+  depthLimit,
+  serializeErrorStacks
 }) {
   const resolved = resolveCodecOptions({
     plugins,
     disabledFeatures,
-    depthLimit
+    depthLimit,
+    serializeErrorStacks
   });
   const refs = new Map();
   const cancels = new Set();
@@ -196,7 +202,7 @@ function createJSONSerializer({
       const stream = seroval.toCrossJSONStream(value, {
         refs,
         plugins: resolved.plugins,
-        disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures(),
+        disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures(resolved.serializeErrorStacks),
         onParse(node, initial) {
           onData({
             key,
@@ -233,6 +239,10 @@ const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
 function isResponseEnvelope(value) {
   return !!(value && typeof value === "object" && value[ENVELOPE]);
 }
+const SAFE_ERROR = Symbol.for("solid.SafeError");
+function isSafeError(value) {
+  return !!(value && (typeof value === "object" || typeof value === "function") && value[SAFE_ERROR]);
+}
 const REVALIDATE_HEADER = "X-Revalidate";
 
 function frameAddress(id, args) {
@@ -281,6 +291,7 @@ function stableString(value, seen) {
 }
 const ERROR_HEADER = "X-Server-Function-Error";
 const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const REDIRECT_HEADER = "X-Server-Function-Redirect";
 const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
 function createChunk(data) {
   const encoder = new TextEncoder();
@@ -294,18 +305,34 @@ function createChunk(data) {
 class ChunkReader {
   constructor(stream) {
     this.reader = stream.getReader();
-    this.buffer = new Uint8Array(0);
+    this.store = new Uint8Array(0);
+    this.buffer = this.store;
     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 {
+    if (chunk.done) {
       this.done = true;
+      return;
+    }
+    const incoming = chunk.value;
+    const store = this.store;
+    const start = this.buffer.byteOffset;
+    const end = start + this.buffer.length;
+    const needed = this.buffer.length + incoming.length;
+    if (end + incoming.length <= store.length) {
+      store.set(incoming, end);
+      this.buffer = store.subarray(start, end + incoming.length);
+    } else if (needed <= store.length) {
+      store.copyWithin(0, start, end);
+      store.set(incoming, this.buffer.length);
+      this.buffer = store.subarray(0, needed);
+    } else {
+      const grown = new Uint8Array(Math.max(needed, store.length * 2));
+      grown.set(this.buffer);
+      grown.set(incoming, this.buffer.length);
+      this.store = grown;
+      this.buffer = grown.subarray(0, needed);
     }
   }
   async next() {
@@ -405,7 +432,8 @@ function resourceIdentity(tag, props) {
   let id = "res:" + tag + ":" + (props.rel || "") + ":" + (props.href || props.src || "");
   for (let i = 0; i < RESOURCE_QUALIFIERS.length; i++) {
     const q = RESOURCE_QUALIFIERS[i];
-    if (props[q] != null) id += ":" + q + "=" + props[q];
+    const value = props[q];
+    if (value != null) id += ":" + q + "=" + (value === true ? "" : value);
   }
   return id;
 }
@@ -467,6 +495,7 @@ function resolveAssets(moduleUrl, manifest) {
   if (!entry) return null;
   const css = [];
   const js = [];
+  let preloads;
   const visited = new Set();
   const walk = key => {
     if (visited.has(key)) return;
@@ -475,13 +504,26 @@ function resolveAssets(moduleUrl, manifest) {
     if (!e) return;
     js.push(joinAssetPath(base, e.file));
     if (e.css) for (let i = 0; i < e.css.length; i++) css.push(joinAssetPath(base, e.css[i]));
+    if (e.preloads) {
+      for (let i = 0; i < e.preloads.length; i++) {
+        const link = e.preloads[i];
+        if (!link || typeof link.href !== "string" || !link.href) continue;
+        if (!preloads) preloads = [];
+        preloads.push({
+          ...link,
+          href: joinAssetPath(base, link.href)
+        });
+      }
+    }
     if (e.imports) for (let i = 0; i < e.imports.length; i++) walk(e.imports[i]);
   };
   walk(moduleUrl);
-  return {
+  const assets = {
     js,
     css
   };
+  if (preloads) assets.preloads = preloads;
+  return assets;
 }
 function registerEntryAssets(manifest) {
   if (!manifest || typeof manifest === "function" || typeof manifest.resolve === "function") return;
@@ -491,6 +533,7 @@ function registerEntryAssets(manifest) {
     if (manifest[key].isEntry) {
       const assets = resolveAssets(key, manifest);
       if (assets) {
+        if (assets.preloads) for (let i = 0; i < assets.preloads.length; i++) ctx.registerAsset("preload", assets.preloads[i]);
         for (let i = 0; i < assets.css.length; i++) ctx.registerAsset("style", assets.css[i]);
         for (let i = 1; i < assets.js.length; i++) ctx.registerAsset("module", assets.js[i]);
       }
@@ -509,6 +552,7 @@ function createAssetTracking() {
     boundaryStyles,
     emittedAssets,
     inlineStyles,
+    preloadLinks: null,
     registerInlineStyle(desc) {
       let entry = inlineStyles.get(desc.id);
       if (!entry) {
@@ -600,6 +644,56 @@ function isCssUrl(url) {
   const q = url.search(/[?#]/);
   return (q === -1 ? url : url.slice(0, q)).endsWith(".css");
 }
+const PRELOAD_LINK_ATTRIBUTES = ["type", "crossorigin", "integrity", "referrerpolicy", "fetchpriority", "media"];
+function registerPreloadLink(tracking, headRegistry, link, nonce) {
+  if (!link || typeof link !== "object" || typeof link.href !== "string" || !link.href) {
+    return null;
+  }
+  if (typeof link.as !== "string") {
+    return null;
+  }
+  const as = asciiLowerCase(link.as);
+  let destination = null;
+  switch (as) {
+    case "script":
+    case "style":
+      destination = as;
+      break;
+    case "fetch":
+    case "font":
+    case "image":
+    case "track":
+      break;
+    default:
+      return null;
+  }
+  const props = {
+    rel: "preload",
+    href: link.href,
+    as
+  };
+  for (let i = 0; i < PRELOAD_LINK_ATTRIBUTES.length; i++) {
+    const name = PRELOAD_LINK_ATTRIBUTES[i];
+    const value = link[name];
+    if (value == null || value === false) continue;
+    props[name] = value === true ? "" : String(value);
+  }
+  const identity = resourceIdentity("link", props);
+  if (headRegistry.resources.has(identity)) return null;
+  const attrs = headAttrRecord(props);
+  const nonceValue = destination && nonce && nonce[destination];
+  if (typeof nonceValue === "string" && nonceValue) attrs.nonce = nonceValue;
+  const entry = {
+    href: props.href,
+    attrs,
+    attrHtml: renderHeadAttrHtml(props) + nonceAttr(nonce, destination)
+  };
+  headRegistry.resources.add(identity);
+  let links = tracking.preloadLinks;
+  if (!links) tracking.preloadLinks = links = [];
+  links.push(entry);
+  return entry;
+}
 function createHeadRegistry() {
   return {
     pending: [],
@@ -1169,6 +1263,8 @@ function renderToStream(code, options = {}) {
     asset(type, value) {
       if (type === "module") {
         buffer.write(`<link rel="modulepreload" href="${value}"${nonceAttr(nonce, "script")}>`);
+      } else if (type === "preload") {
+        buffer.write(`<link${value.attrHtml}>`);
       } else if (type === "inline-style") {
         buffer.write(renderInlineStyle(value, nonce));
       } else if (type === "head-tag") {
@@ -1176,7 +1272,7 @@ function renderToStream(code, options = {}) {
       }
     },
     shell(shellHtml, meta) {
-      buffer.write(assembleDocument(shellHtml, meta.preloads, meta.inlineStyles, meta.tasks.length ? meta.tasks : "", nonce, meta.head, onHead));
+      buffer.write(assembleDocument(shellHtml, meta.preloads, meta.preloadLinks, meta.inlineStyles, meta.tasks.length ? meta.tasks : "", nonce, meta.head, onHead));
     },
     ...options.sink
   };
@@ -1209,6 +1305,29 @@ function renderToStream(code, options = {}) {
     }
   };
   const registry = new Map();
+  const pendingSerialized = new Map();
+  const trackSerialized = (id, p) => {
+    let settle;
+    const raced = Promise.race([p, new Promise(r => settle = r)]);
+    pendingSerialized.set(id, settle);
+    const drop = () => pendingSerialized.delete(id);
+    p.then(drop, drop);
+    return raced;
+  };
+  const abandonSubtree = key => {
+    for (const [k, entry] of registry) {
+      if (k.length > key.length && k.startsWith(key)) {
+        registry.delete(k);
+        entry.resolve();
+      }
+    }
+    for (const [id, settle] of pendingSerialized) {
+      if (id.startsWith(key)) {
+        pendingSerialized.delete(id);
+        settle();
+      }
+    }
+  };
   const writeTasks = () => {
     if (tasks.length && !completed && firstFlushed) {
       buffer.write(`<script${nonceAttr(nonce, "script")}>${tasks}</script>`);
@@ -1279,6 +1398,11 @@ function renderToStream(code, options = {}) {
       }, nonce, tags);
     },
     registerAsset(type, value) {
+      if (type === "preload") {
+        const entry = registerPreloadLink(tracking, headRegistry, value, nonce);
+        if (entry && firstFlushed) sink.asset("preload", entry);
+        return;
+      }
       if (type === "inline-style") {
         const entry = tracking.registerInlineStyle(value);
         if (firstFlushed && !tracking.currentBoundaryId && !entry.emitted) {
@@ -1323,13 +1447,14 @@ function renderToStream(code, options = {}) {
     },
     serialize(id, p, deferStream) {
       if (solidJs.sharedConfig.context.noHydrate) return;
-      if (!firstFlushed && p && typeof p === "object" && "then" in p) {
-        if (deferStream) {
+      if (p && typeof p === "object" && typeof p.then === "function") {
+        if (!firstFlushed && deferStream) {
           blockingPromises.add(p);
           p.then(d => serializer.write(id, d)).catch(e => serializer.write(id, e));
           return;
         }
-        if (canBatchStubs && !shellCompleted) {
+        p = trackSerialized(id, p);
+        if (!firstFlushed && canBatchStubs && !shellCompleted) {
           (stubBatch ||= new Map()).set(id, p);
           return;
         }
@@ -1374,6 +1499,7 @@ function renderToStream(code, options = {}) {
         if (registry.has(key)) {
           const item = registry.get(key);
           registry.delete(key);
+          if (error) abandonSubtree(key);
           if (item.children) {
             for (const k in item.children) {
               value = replacePlaceholder(value, k, item.children[k]);
@@ -1498,6 +1624,7 @@ function renderToStream(code, options = {}) {
     const head = renderShellHead(headRegistry, nonce, k => registry.has(k), noScripts);
     sink.shell(resolveSSRSelectValues(html), {
       preloads: tracking.emittedAssets,
+      preloadLinks: tracking.preloadLinks,
       inlineStyles: tracking.inlineStyles,
       tasks,
       head
@@ -2419,12 +2546,12 @@ function allSettled(promises) {
     return;
   });
 }
-function assembleDocument(html, emittedAssets, inlineStyles, scripts, nonce, headTags, onHead) {
+function assembleDocument(html, emittedAssets, preloadLinks, inlineStyles, scripts, nonce, headTags, onHead) {
   const scriptTag = scripts ? `<script${nonceAttr(nonce, "script")}>${scripts}</script>` : "";
   const title = headTags ? headTags.title : null;
   let headTagsHtml = headTags ? headTags.html : "";
   const headPrelude = headTags ? headTags.prelude : "";
-  if (!onHead && title == null && !headTagsHtml && !headPrelude && !(emittedAssets && emittedAssets.size) && !(inlineStyles && inlineStyles.size)) {
+  if (!onHead && title == null && !headTagsHtml && !headPrelude && !(emittedAssets && emittedAssets.size) && !preloadLinks && !(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);
@@ -2443,7 +2570,7 @@ function assembleDocument(html, emittedAssets, inlineStyles, scripts, nonce, hea
       if (title != null) {
         titleHtml = headTags.noScripts ? `<title data-dh="title">${escape(title)}</title>` : `<script${nonceAttr(nonce, "script")}>(function(x,t){(t=document.querySelector("title"))?(t.hasAttribute("data-dh")||t.setAttribute("data-dhf",t.textContent),t.textContent=x):(document.title=x,t=document.querySelector("title"));t&&t.setAttribute("data-dh","title")})(${JSON.stringify(title).replace(/</g, "\\u003C")})</script>`;
       }
-      onHead(headPrelude + headTagsHtml + titleHtml + renderHeadAssets(emittedAssets, inlineStyles, nonce));
+      onHead(headPrelude + headTagsHtml + titleHtml + renderHeadAssets(emittedAssets, preloadLinks, inlineStyles, nonce));
     }
     if (!scriptTag) return html;
     const xs = html.indexOf("<!--xs-->");
@@ -2463,13 +2590,13 @@ function assembleDocument(html, emittedAssets, inlineStyles, scripts, nonce, hea
       headTagsHtml = `<title data-dh="title">${winner}</title>` + headTagsHtml;
     }
   }
-  const head = headTagsHtml + renderHeadAssets(emittedAssets, inlineStyles, nonce);
+  const head = headTagsHtml + renderHeadAssets(emittedAssets, preloadLinks, inlineStyles, nonce);
   if (!scriptTag) return html.slice(0, headIdx) + head + html.slice(headIdx);
   const xsIdx = html.indexOf("<!--xs-->");
   if (xsIdx === -1) return html.slice(0, headIdx) + head + html.slice(headIdx) + scriptTag;
   return xsIdx < headIdx ? html.slice(0, xsIdx) + scriptTag + html.slice(xsIdx, headIdx) + head + html.slice(headIdx) : html.slice(0, headIdx) + head + html.slice(headIdx, xsIdx) + scriptTag + html.slice(xsIdx);
 }
-function renderHeadAssets(emittedAssets, inlineStyles, nonce) {
+function renderHeadAssets(emittedAssets, preloadLinks, inlineStyles, nonce) {
   let head = "";
   const styleAttr = nonceAttr(nonce, "style");
   const scriptAttr = nonceAttr(nonce, "script");
@@ -2478,6 +2605,9 @@ function renderHeadAssets(emittedAssets, inlineStyles, nonce) {
       head += isCssUrl(url) ? `<link rel="stylesheet" href="${url}"${styleAttr}>` : `<link rel="modulepreload" href="${url}"${scriptAttr}>`;
     }
   }
+  if (preloadLinks) {
+    for (const entry of preloadLinks) head += `<link${entry.attrHtml}>`;
+  }
   if (inlineStyles && inlineStyles.size) {
     for (const entry of inlineStyles.values()) {
       if (entry.emitted) continue;
@@ -2663,12 +2793,312 @@ 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?");
 }
-/*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, "Location"].map(header => header.toLowerCase()));
+/*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, REDIRECT_HEADER, "Location",
+...COMPOSED_BODY_FRAMING].map(header => header.toLowerCase()));
 
+function scopeDeferredResult(value, scope) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return value;
+  const promised = scope(() => nativePromise(value));
+  if (promised) {
+    return promised.then(result => scope(() => scopeDeferredResult(result, scope)));
+  }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    let reader;
+    return new ReadableStream({
+      async pull(controller) {
+        try {
+          const step = await scope(() => {
+            if (!reader) reader = value.getReader();
+            return reader.read();
+          });
+          if (step.done) controller.close();else controller.enqueue(step.value);
+        } catch (error) {
+          controller.error(error);
+        }
+      },
+      cancel(reason) {
+        return scope(() => reader ? reader.cancel(reason) : value.cancel(reason));
+      }
+    }, {
+      highWaterMark: 0
+    });
+  }
+  const scopedIterator = symbol => ({
+    [symbol]() {
+      const iterator = scope(() => value[symbol]());
+      return new Proxy(iterator, {
+        get(target, property) {
+          const member = Reflect.get(target, property, target);
+          return typeof member === "function" && (property === "next" || property === "return" || property === "throw") ? (...args) => scope(() => member.apply(target, args)) : member;
+        }
+      });
+    }
+  });
+  if (typeof value[Symbol.asyncIterator] === "function") {
+    return scopedIterator(Symbol.asyncIterator);
+  }
+  if (typeof value[Symbol.iterator] === "function" && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !ArrayBuffer.isView(value)) {
+    return scopedIterator(Symbol.iterator);
+  }
+  return value;
+}
 const INVOCATIONS = new WeakMap();
 function getEventServerFunctionInvocation(event) {
   return event && INVOCATIONS.get(event);
 }
+function guardFailures(value, state) {
+  if (!state) state = {
+    seen: new WeakMap(),
+    cyclic: new WeakSet()
+  };
+  const entered = enterGuard(value, state);
+  if (!(entered instanceof Frame)) return entered;
+  const stack = [entered];
+  let delivered = NOTHING;
+  for (;;) {
+    const top = stack[stack.length - 1];
+    const items = top.items;
+    let pushed = null;
+    while (top.i < items.length) {
+      const i = top.i;
+      let original;
+      if (top.kind === OBJECT) {
+        const descriptor = top.descriptors[items[i]];
+        if ("value" in descriptor) {
+          original = descriptor.value;
+        } else if (typeof descriptor.get === "function") {
+          if (top.accessorRead !== i) {
+            try {
+              top.accessorValue = descriptor.get.call(top.value);
+            } catch (error) {
+              throw sanitizeServerError(error);
+            }
+            top.accessorRead = i;
+          }
+          original = top.accessorValue;
+        } else {
+          top.i++;
+          continue;
+        }
+      } else {
+        original = items[i];
+      }
+      let guarded;
+      if (delivered !== NOTHING) {
+        guarded = delivered;
+        delivered = NOTHING;
+      } else {
+        guarded = enterGuard(original, state);
+        if (guarded instanceof Frame) {
+          pushed = guarded;
+          break;
+        }
+      }
+      if (top.kind === ARRAY) {
+        if (guarded !== original) {
+          top.next[i] = guarded;
+          top.changed = true;
+        }
+      } else if (top.kind === MAP) {
+        if ((i & 1) === 0) top.pendingKey = guarded;else top.next.set(top.pendingKey, guarded);
+        if (guarded !== original) top.changed = true;
+      } else if (top.kind === SET) {
+        top.next.add(guarded);
+        if (guarded !== original) top.changed = true;
+      } else if (guarded !== original || top.accessorRead === i) {
+        Object.defineProperty(top.next, items[i], {
+          value: guarded,
+          writable: true,
+          configurable: true,
+          enumerable: top.descriptors[items[i]].enumerable
+        });
+        top.changed = true;
+      }
+      top.i++;
+    }
+    if (pushed !== null) {
+      stack.push(pushed);
+      continue;
+    }
+    stack.pop();
+    const out = keepGuarded(top.value, top.next, top.changed, state);
+    if (stack.length === 0) return out;
+    delivered = out;
+  }
+}
+const NOTHING = Symbol();
+const ARRAY = 0;
+const MAP = 1;
+const SET = 2;
+const OBJECT = 3;
+class Frame {
+  constructor(kind, value, next, items, descriptors) {
+    this.kind = kind;
+    this.value = value;
+    this.next = next;
+    this.items = items;
+    this.descriptors = descriptors;
+    this.i = 0;
+    this.changed = false;
+    this.accessorRead = -1;
+    this.accessorValue = undefined;
+    this.pendingKey = undefined;
+  }
+}
+function guardOperation(state, run) {
+  return state.scope ? state.scope(run) : run();
+}
+function enterGuard(value, state) {
+  if (value === null || typeof value !== "object") return value;
+  if (state.seen.has(value)) {
+    state.cyclic.add(value);
+    return state.seen.get(value);
+  }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    let reader;
+    const gate = state.gate;
+    let finished = false;
+    const close = () => {
+      if (finished) return;
+      finished = true;
+      try {
+        const cancelled = guardOperation(state, () => reader ? reader.cancel() : value.cancel());
+        if (cancelled && typeof cancelled.then === "function") cancelled.then(undefined, () => {});
+      } catch {}
+    };
+    const guardedStream = new ReadableStream({
+      async pull(controller) {
+        try {
+          if (gate && !finished && !gate.wantsMore()) await gate.awaitDemand();
+          if (finished) {
+            controller.close();
+            return;
+          }
+          if (!reader) reader = guardOperation(state, () => value.getReader());
+          const {
+            done,
+            value: chunk
+          } = await guardOperation(state, () => reader.read());
+          done ? controller.close() : controller.enqueue(guardOperation(state, () => guardFailures(chunk, state)));
+        } catch (error) {
+          controller.error(guardOperation(state, () => sanitizeServerError(error)));
+        }
+      },
+      cancel(reason) {
+        finished = true;
+        return guardOperation(state, () => reader ? reader.cancel(reason) : value.cancel(reason));
+      }
+    });
+    if (gate) gate.onOpen(close);
+    state.seen.set(value, guardedStream);
+    return guardedStream;
+  }
+  if (typeof value.then === "function") {
+    const guardedPromise = Promise.resolve(value).then(resolved => guardOperation(state, () => guardFailures(resolved, state)), error => {
+      throw guardOperation(state, () => sanitizeServerError(error));
+    });
+    guardedPromise.catch(() => {});
+    state.seen.set(value, guardedPromise);
+    return guardedPromise;
+  }
+  if (typeof value[Symbol.asyncIterator] === "function") {
+    const source = value;
+    const gate = state.gate;
+    const guardedIterable = {
+      [Symbol.asyncIterator]() {
+        const iterator = guardOperation(state, () => source[Symbol.asyncIterator]());
+        let finished = false;
+        const close = () => {
+          if (finished) return;
+          finished = true;
+          try {
+            const returned = iterator.return && guardOperation(state, () => iterator.return());
+            if (returned && typeof returned.then === "function") returned.then(undefined, () => {});
+          } catch {}
+        };
+        if (gate) gate.onOpen(close);
+        const step = () => finished ? Promise.resolve({
+          done: true,
+          value: undefined
+        }) : guardOperation(state, () => iterator.next()).then(step => {
+          if (step.done) {
+            finished = true;
+            return step;
+          }
+          return {
+            done: false,
+            value: guardOperation(state, () => guardFailures(step.value, state))
+          };
+        }, error => {
+          throw guardOperation(state, () => sanitizeServerError(error));
+        });
+        return {
+          next: () => finished || !gate || gate.wantsMore() ? step() : gate.awaitDemand().then(step),
+          return: () => {
+            close();
+            return Promise.resolve({
+              done: true,
+              value: undefined
+            });
+          }
+        };
+      }
+    };
+    state.seen.set(value, guardedIterable);
+    return guardedIterable;
+  }
+  if (state.scope && typeof value[Symbol.iterator] === "function" && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !ArrayBuffer.isView(value)) {
+    const scopedIterable = scopeDeferredResult(value, state.scope);
+    state.seen.set(value, scopedIterable);
+    return scopedIterable;
+  }
+  if (Array.isArray(value)) {
+    const next = value.slice();
+    state.seen.set(value, next);
+    return new Frame(ARRAY, value, next, value, null);
+  }
+  if (value instanceof Map) {
+    const next = new Map();
+    state.seen.set(value, next);
+    const items = [];
+    for (const entry of value) items.push(entry[0], entry[1]);
+    return new Frame(MAP, value, next, items, null);
+  }
+  if (value instanceof Set) {
+    const next = new Set();
+    state.seen.set(value, next);
+    return new Frame(SET, value, next, [...value], null);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    state.seen.set(value, value);
+    return value;
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Object.keys(descriptors)) {
+    descriptors[key].configurable = true;
+    if ("value" in descriptors[key]) descriptors[key].writable = true;
+  }
+  const next = Object.create(prototype, descriptors);
+  state.seen.set(value, next);
+  return new Frame(OBJECT, value, next, Object.keys(value), descriptors);
+}
+function keepGuarded(value, next, changed, state) {
+  if (changed || state.cyclic.has(value)) return next;
+  state.seen.set(value, value);
+  return value;
+}
+const GENERIC_SERVER_ERROR_MESSAGE = "Internal Server Error";
+function sanitizeServerError(value) {
+  if (isSafeError(value)) return value;
+  return new Error(GENERIC_SERVER_ERROR_MESSAGE);
+}
+function nativePromise(value) {
+  if (value instanceof Promise) return value;
+  try {
+    if (Object.prototype.toString.call(value) === "[object Promise]") return Promise.prototype.then.call(value, value => value);
+  } catch {}
+}
 
 const FRAME_STREAM_HEADER = "X-Frame-Stream";
 function isFrameStreamResponse(response) {
@@ -2738,6 +3168,12 @@ function serverOwned(render) {
 function serverComponentScope(render) {
   return solidJs.runInServerComponentScope ? solidJs.runInServerComponentScope(render) : render();
 }
+function wirePreload(entry) {
+  return {
+    href: entry.href,
+    attrs: entry.attrs
+  };
+}
 const SERVER_COMPONENT_BOOTSTRAP_EXPR = "(self._$SC||(self._$SC={c:{},a:{},r(i,a){a&&(this.a[a]=i,this.reg&&this.reg(a,i));return this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b))}}))";
 const bootstrappedScripts = new WeakSet();
 setServerComponentBootstrap(ctx => {
@@ -2782,20 +3218,28 @@ function createFrameSink(emit, frame) {
       if (!regionKeys.has(key)) regionKeys.set(key, childId);
     },
     shell(html, meta = {}) {
-      if (meta.preloads && meta.preloads.size) {
-        const styles = [];
-        const modules = [];
-        for (const url of meta.preloads) {
-          (url.endsWith(".css") ? styles : modules).push(url);
-        }
+      if (meta.preloads && meta.preloads.size || meta.preloadLinks) {
         const chunk = {
           type: "assets",
           id,
           version,
           key: ""
         };
-        if (styles.length) chunk.styles = styles;
-        if (modules.length) chunk.modules = modules;
+        if (meta.preloads && meta.preloads.size) {
+          const styles = [];
+          const modules = [];
+          for (const url of meta.preloads) {
+            (url.endsWith(".css") ? styles : modules).push(url);
+          }
+          if (styles.length) chunk.styles = styles;
+          if (modules.length) chunk.modules = modules;
+        }
+        if (meta.preloadLinks) {
+          chunk.preloads = [];
+          for (const entry of meta.preloadLinks) {
+            chunk.preloads.push(wirePreload(entry));
+          }
+        }
         emit(chunk);
       }
       emit({
@@ -2907,15 +3351,24 @@ function createFrameSink(emit, frame) {
         emit(chunk);
       }
     },
-    asset(type, url) {
-      if (type !== "module") return;
-      emit({
-        type: "assets",
-        id,
-        version,
-        key: "",
-        modules: [url]
-      });
+    asset(type, value) {
+      if (type === "module") {
+        emit({
+          type: "assets",
+          id,
+          version,
+          key: "",
+          modules: [value]
+        });
+      } else if (type === "preload") {
+        emit({
+          type: "assets",
+          id,
+          version,
+          key: "",
+          preloads: [wirePreload(value)]
+        });
+      }
     },
     end() {
       if (bindings.size) sweep();
@@ -3839,7 +4292,7 @@ function frameFlightResponse({
           });
         }
         if (outcome) {
-          const reader = new ChunkReader(serializeStream(outcome, flightCodec(codec)));
+          const reader = new ChunkReader(serializeStream(guardFailures(outcome), flightCodec(codec)));
           for (let node = await reader.next(); !node.done; node = await reader.next()) {
             write({
               type: "outcome",