@qredence/fleet 0.7.0 → 0.7.1

package/dist/web/server/server.js

@@ -1,46 +1,869 @@
 import {
-  GLOBAL_TSR,
+  RawStream,
   RouterProvider,
-  TSR_SCRIPT_BARRIER_ID,
   _getRenderedMatches,
   createInlineCssPlaceholderAsset,
   createInlineCssStyleAsset,
-  createLRUCache,
-  createMemoryHistory,
-  createRawStreamRPCPlugin,
+  createPlugin,
   createSerializationAdapter,
+  createServerHistory,
+  createSieveCache,
+  createStream,
   crossSerializeStream,
   decodePath,
-  defaultSerovalPlugins,
   dehydrateSsrMatchId,
   executeRewriteInput,
   getCrossReferenceHeader,
   getScriptPreloadAttrs,
   getStylesheetHref,
   invariant,
+  isDangerousProtocol,
   isNotFound,
+  isPromise,
   isRedirect,
-  isResolvedRedirect,
+  isStream,
   makeSerovalPlugin,
-  makeSsrSerovalPlugin,
   resolveManifestAssetLink,
   resolveManifestCssLink,
-  rootRouteId
-} from "./chunk-F5DJQ3PQ.js";
+  rootRouteId,
+  waitForReason
+} from "./chunk-WPSI5TBE.js";
 import "./chunk-CZ7CSFO4.js";
 
 // web/app/dist/server/server.js
 import "react";
 import { jsx } from "react/jsx-runtime";
 
-// node_modules/.pnpm/@tanstack+router-core@1.171.27/node_modules/@tanstack/router-core/dist/esm/ssr/tsrScript.js
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/ShallowErrorPlugin.js
+var ShallowErrorPlugin = /* @__PURE__ */ createPlugin({
+  tag: "$TSR/Error",
+  test(value) {
+    return value instanceof Error;
+  },
+  parse: {
+    sync(value, ctx) {
+      return { message: ctx.parse(value.message) };
+    },
+    async async(value, ctx) {
+      return { message: await ctx.parse(value.message) };
+    },
+    stream(value, ctx) {
+      return { message: ctx.parse(value.message) };
+    }
+  },
+  serialize(node, ctx) {
+    return "new Error(" + ctx.serialize(node.message) + ")";
+  },
+  deserialize(node, ctx) {
+    return new Error(ctx.deserialize(node.message));
+  }
+});
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/rawStreamCodec.js
+function toBase64(bytes) {
+  const chunks = [];
+  for (let i = 0; i < bytes.length; i += 32768) chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + 32768)));
+  return btoa(chunks.join(""));
+}
+function fromBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+var textDecoder = /* @__PURE__ */ new TextDecoder("utf-8", {
+  fatal: true,
+  ignoreBOM: true
+});
+function encodeText(value) {
+  try {
+    return "t" + textDecoder.decode(value);
+  } catch {
+    return "b" + toBase64(value);
+  }
+}
+var textEncoder = /* @__PURE__ */ new TextEncoder();
+function decodeText(value) {
+  const data = value.slice(1);
+  return value[0] === "t" ? textEncoder.encode(data) : fromBase64(data);
+}
+function pumpEncodedStream(readable, encode, signal) {
+  signal?.throwIfAborted();
+  const stream = createStream();
+  const reader = readable.getReader();
+  let active = true;
+  const release = () => {
+    active = false;
+    signal?.removeEventListener("abort", abort);
+    reader.releaseLock();
+  };
+  const stop = (reason) => {
+    if (!active) return false;
+    reader.cancel(reason).catch(() => {
+    });
+    release();
+    return true;
+  };
+  const abort = () => {
+    if (stop(signal.reason)) stream.throw(signal.reason);
+  };
+  signal?.addEventListener("abort", abort);
+  (async () => {
+    try {
+      while (active) {
+        const { done, value } = await reader.read();
+        if (!active) return;
+        if (done) {
+          release();
+          stream.return(void 0);
+          return;
+        }
+        stream.next(encode(value));
+      }
+    } catch (error) {
+      if (stop(error)) stream.throw(error);
+    }
+  })();
+  return [stream, stop];
+}
+function fromEncodedStream(source, decode) {
+  let unsubscribe;
+  let done = false;
+  return new ReadableStream({
+    start(controller) {
+      const dispose = source.on({
+        next(value) {
+          if (done) return;
+          try {
+            controller.enqueue(decode(value));
+          } catch (error) {
+            done = true;
+            const stop = unsubscribe;
+            unsubscribe = void 0;
+            stop?.();
+            controller.error(error);
+          }
+        },
+        throw(error) {
+          if (!done) {
+            done = true;
+            unsubscribe = void 0;
+            controller.error(error);
+          }
+        },
+        return() {
+          if (!done) {
+            done = true;
+            unsubscribe = void 0;
+            controller.close();
+          }
+        }
+      });
+      if (done) dispose();
+      else unsubscribe = dispose;
+    },
+    cancel() {
+      const dispose = unsubscribe;
+      unsubscribe = void 0;
+      dispose?.();
+    }
+  });
+}
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/RawStreamJSONPlugin.js
+// @__NO_SIDE_EFFECTS__
+function createRawStreamJSONPlugin(signal) {
+  return /* @__PURE__ */ createPlugin({
+    tag: "tss/RawStream",
+    test: (value) => value instanceof RawStream,
+    parse: { async: async (value, ctx) => {
+      const text = await ctx.parse(value.hint === "text");
+      const [stream] = pumpEncodedStream(value.stream, value.hint === "text" ? encodeText : toBase64, signal);
+      return {
+        text,
+        stream: await ctx.parse(stream)
+      };
+    } },
+    serialize: void 0,
+    deserialize: void 0
+  });
+}
+var RawStreamJSONPlugin = /* @__PURE__ */ createRawStreamJSONPlugin();
+var RawStreamJSONDeserializePlugin = /* @__PURE__ */ createPlugin({
+  tag: "tss/RawStream",
+  test: () => false,
+  parse: {},
+  serialize: void 0,
+  deserialize(node, ctx) {
+    return fromEncodedStream(ctx.deserialize(node.stream), ctx.deserialize(node.text) ? decodeText : fromBase64);
+  }
+});
+
+// node_modules/.pnpm/seroval-plugins@1.6.7_seroval@1.6.7/node_modules/seroval-plugins/dist/web-CWqRG00W.js
+var READABLE_STREAM_FACTORY = {};
+var READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream) => new ReadableStream({ start(controller) {
+  stream.on({
+    next(value) {
+      try {
+        controller.enqueue(value);
+      } catch (_error) {
+      }
+    },
+    throw(value) {
+      controller.error(value);
+    },
+    return() {
+      try {
+        controller.close();
+      } catch (_error) {
+      }
+    }
+  });
+} });
+var ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin({
+  tag: "seroval-plugins/web/ReadableStreamFactory",
+  test(value) {
+    return value === READABLE_STREAM_FACTORY;
+  },
+  parse: {
+    sync() {
+      return READABLE_STREAM_FACTORY;
+    },
+    async async() {
+      return await Promise.resolve(READABLE_STREAM_FACTORY);
+    },
+    stream() {
+      return READABLE_STREAM_FACTORY;
+    }
+  },
+  serialize() {
+    return READABLE_STREAM_FACTORY_CONSTRUCTOR.toString();
+  },
+  deserialize() {
+    return READABLE_STREAM_FACTORY;
+  }
+});
+async function drainStream(stream, reader) {
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done) {
+        stream.return(result.value);
+        reader.releaseLock();
+        break;
+      }
+      stream.next(result.value);
+    }
+  } catch (error) {
+    reader.releaseLock();
+    stream.throw(error);
+  }
+}
+function cleanupStream(reader) {
+  reader.cancel().catch(() => {
+  });
+  reader.releaseLock();
+}
+function toStream(value) {
+  const stream = createStream();
+  const reader = value.getReader();
+  const cleanup = cleanupStream.bind(null, reader);
+  drainStream(stream, reader).catch(cleanup);
+  return [stream, cleanup];
+}
+var ReadableStreamPlugin = /* @__PURE__ */ createPlugin({
+  tag: "seroval/plugins/web/ReadableStream",
+  extends: [ReadableStreamFactoryPlugin],
+  test(value) {
+    if (typeof ReadableStream === "undefined") return false;
+    return value instanceof ReadableStream;
+  },
+  parse: {
+    sync(_value, ctx) {
+      return {
+        factory: ctx.parse(READABLE_STREAM_FACTORY),
+        stream: ctx.parse(createStream())
+      };
+    },
+    async async(value, ctx) {
+      return {
+        factory: await ctx.parse(READABLE_STREAM_FACTORY),
+        stream: await ctx.parse(toStream(value)[0])
+      };
+    },
+    stream(value, ctx) {
+      const [stream, cleanup] = toStream(value);
+      ctx.addCleanup(cleanup);
+      return {
+        factory: ctx.parse(READABLE_STREAM_FACTORY),
+        stream: ctx.parse(stream)
+      };
+    }
+  },
+  serialize(node, ctx) {
+    return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
+  },
+  deserialize(node, ctx) {
+    const stream = ctx.deserialize(node.stream);
+    if (!stream || typeof stream !== "object" || !isStream(stream)) throw new Error("Expected a stream source.");
+    return READABLE_STREAM_FACTORY_CONSTRUCTOR(stream);
+  }
+});
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/seroval-plugins.js
+// @__NO_SIDE_EFFECTS__
+function createDefaultSerovalPlugins(signal) {
+  return [
+    ShallowErrorPlugin,
+    signal ? /* @__PURE__ */ createRawStreamJSONPlugin(signal) : RawStreamJSONPlugin,
+    ReadableStreamPlugin
+  ];
+}
+var defaultSerovalPlugins = /* @__PURE__ */ createDefaultSerovalPlugins();
+var defaultSerovalDeserializerPlugins = [RawStreamJSONDeserializePlugin, ...defaultSerovalPlugins];
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/RawStreamRPCPlugin.js
+// @__NO_SIDE_EFFECTS__
+function createRawStreamRPCPlugin(onRawStream) {
+  let nextStreamId = 1;
+  return /* @__PURE__ */ createPlugin({
+    tag: "tss/RawStream",
+    test(value) {
+      return value instanceof RawStream;
+    },
+    parse: { stream(value, ctx) {
+      const streamId = nextStreamId++;
+      onRawStream(streamId, value.stream);
+      return { streamId: ctx.parse(streamId) };
+    } },
+    serialize: void 0,
+    deserialize: void 0
+  });
+}
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/constants.js
+var GLOBAL_TSR = "$_TSR";
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/makeSsrSerovalPlugin.js
+// @__NO_SIDE_EFFECTS__
+function makeSsrSerovalPlugin(serializationAdapter, tracker) {
+  return /* @__PURE__ */ createPlugin({
+    tag: "$TSR/t/" + serializationAdapter.key,
+    test: serializationAdapter.test,
+    parse: { stream(value, ctx) {
+      return { v: ctx.parse(serializationAdapter.toSerializable(value)) };
+    } },
+    serialize(node, ctx) {
+      if (tracker) tracker.didRun = true;
+      return GLOBAL_TSR + '.t.get("' + serializationAdapter.key + '")(' + ctx.serialize(node.v) + ")";
+    },
+    deserialize: void 0
+  });
+}
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/tsrScript.js
 var tsrScript_default = "self.$_TSR={h(){this.hydrated=!0,this.c()},e(){this.streamEnded=!0,this.c()},c(){this.hydrated&&this.streamEnded&&(delete self.$_TSR,delete self.$R.tsr)},p(e){this.initialized?e():this.buffer.push(e)},buffer:[]}";
 
-// node_modules/.pnpm/@tanstack+router-core@1.171.27/node_modules/@tanstack/router-core/dist/esm/ssr/ssr-server.js
-var SCOPE_ID = "tsr";
-var TSR_PREFIX = GLOBAL_TSR + ".router=";
-var P_PREFIX = GLOBAL_TSR + ".p(()=>";
-var P_SUFFIX = ")";
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/htmlBoundaryScanner.js
+var textEncoder2 = new TextEncoder();
+var DOCUMENT_CLOSE = "</body></html>";
+var SCRIPT_CLOSE = "</script>";
+var DOCUMENT_CLOSE_ANCHOR_INDEX = DOCUMENT_CLOSE.indexOf("y");
+var SCRIPT_CLOSE_ANCHOR_INDEX = SCRIPT_CLOSE.indexOf("p");
+var DOCUMENT_CLOSE_BYTES = textEncoder2.encode(DOCUMENT_CLOSE);
+var SCRIPT_CLOSE_BYTES = textEncoder2.encode(SCRIPT_CLOSE);
+function encodeIntoBoundedChunk(source, sourceOffset, output, outputOffset = 0) {
+  return textEncoder2.encodeInto(sourceOffset === 0 ? source : source.slice(sourceOffset), outputOffset === 0 ? output : output.subarray(outputOffset));
+}
+function advanceByteMatcher(matcher, value, startIndex = 0, findLast = false) {
+  const { pattern: pattern2, anchorIndex } = matcher;
+  let matched = matcher.matched;
+  let lastMatchEnd;
+  let index = startIndex;
+  while (index < value.length) {
+    if (matched === 0) if (anchorIndex > 0 && index < value.length - anchorIndex) {
+      const anchor = value.indexOf(pattern2[anchorIndex], index + anchorIndex);
+      if (anchor < 0) {
+        index = value.length - anchorIndex;
+        continue;
+      }
+      index = anchor - anchorIndex;
+    } else {
+      index = value.indexOf(pattern2[0], index);
+      if (index < 0) {
+        matcher.matched = matched;
+        return lastMatchEnd;
+      }
+    }
+    const byte = value[index];
+    if (byte === pattern2[matched]) matched++;
+    else matched = byte === pattern2[0] ? 1 : 0;
+    index++;
+    if (matched === pattern2.length) {
+      matched = 0;
+      if (!findLast) {
+        matcher.matched = matched;
+        return index;
+      }
+      lastMatchEnd = index;
+    }
+  }
+  matcher.matched = matched;
+  return lastMatchEnd;
+}
+function findExactBytes(value, pattern2, startIndex = 0, anchorIndex = 0) {
+  let anchor = value.indexOf(pattern2[anchorIndex], startIndex + anchorIndex);
+  while (anchor >= 0) {
+    const candidate = anchor - anchorIndex;
+    if (candidate + pattern2.length > value.length) return -1;
+    let patternIndex = 0;
+    while (patternIndex < pattern2.length && value[candidate + patternIndex] === pattern2[patternIndex]) patternIndex++;
+    if (patternIndex === pattern2.length) return candidate;
+    anchor = value.indexOf(pattern2[anchorIndex], anchor + 1);
+  }
+  return -1;
+}
+function getExactBytesPrefixAtEnd(value, pattern2, startIndex = 0) {
+  candidate: for (let length = Math.min(pattern2.length - 1, value.length - startIndex); length > 0; length--) {
+    const candidateStart = value.length - length;
+    for (let index = 0; index < length; index++) if (value[candidateStart + index] !== pattern2[index]) continue candidate;
+    return candidateStart;
+  }
+}
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/hydrationScripts.js
+var encoder = new TextEncoder();
+var SOURCE_SEPARATOR = ";";
+var MAX_INITIAL_SOURCE_CODE_UNITS = 16 * 1024;
+var MAX_BACKLOG_CODE_UNITS = 16 * 1024 * 1024;
+var MAX_BACKLOG_SOURCES = 4096;
+var MIN_OUTPUT_BYTES = 256;
+var MAX_DIRECT_CODE_UNITS = 16 * 1024;
+var MAX_HYDRATION_OUTPUT_CHUNK_BYTES = 64 * 1024;
+var MAX_DYNAMIC_RECORD_CODE_UNITS = MAX_HYDRATION_OUTPUT_CHUNK_BYTES;
+var STREAM_PART_ATTRIBUTE = "data-tsr-stream-part";
+var INITIAL_CLEANUP_SOURCE = `{let s=document.currentScript,p;while((p=s.previousElementSibling)&&p.hasAttribute('${STREAM_PART_ATTRIBUTE}'))p.remove();s.remove()}`;
+var INITIAL_CLEANUP_SUFFIX = SOURCE_SEPARATOR + INITIAL_CLEANUP_SOURCE;
+var DYNAMIC_CLOSE_SOURCE = "document.currentScript.remove()</script>";
+var HYDRATION_SCRIPT_BOUNDARY_SOURCE = "document.currentScript.remove();/*$tsr-stream-boundary*/";
+var HYDRATION_SCRIPT_BOUNDARY_SUFFIX = ";/*$tsr-stream-boundary*/</script>";
+var HYDRATION_SCRIPT_BOUNDARY_ANCHOR_INDEX = HYDRATION_SCRIPT_BOUNDARY_SUFFIX.lastIndexOf("*");
+var HYDRATION_SCRIPT_BOUNDARY_BYTES = encoder.encode(HYDRATION_SCRIPT_BOUNDARY_SUFFIX);
+var ROUTER_PREFIX = GLOBAL_TSR + ".router=";
+var PROMISE_PREFIX = GLOBAL_TSR + ".p(()=>";
+var DEFAULT_INITIAL_SOURCES = [getCrossReferenceHeader("tsr"), tsrScript_default];
+var HydrationScriptOutputState = {
+  Waiting: 0,
+  Ready: 1,
+  Active: 2,
+  Done: 3,
+  Failed: 4
+};
+function escapeAttribute(value) {
+  return value.replace(/[&"'<>]/g, (char) => `&#${char.charCodeAt(0)};`);
+}
+function createInitialTags(sources, nonce) {
+  const before = [];
+  for (const source of sources) {
+    if (!source) continue;
+    const previous = before[before.length - 1];
+    if (previous?.children && previous.children.length + 1 + source.length <= MAX_INITIAL_SOURCE_CODE_UNITS) previous.children += SOURCE_SEPARATOR + source;
+    else before.push({
+      tag: "script",
+      attrs: {
+        nonce,
+        [STREAM_PART_ATTRIBUTE]: ""
+      },
+      children: source
+    });
+  }
+  const lastHydrationTag = before[before.length - 1];
+  if (lastHydrationTag) {
+    const lastSource = lastHydrationTag.children;
+    if (lastSource.length + INITIAL_CLEANUP_SUFFIX.length <= MAX_INITIAL_SOURCE_CODE_UNITS) lastHydrationTag.children = lastSource + INITIAL_CLEANUP_SUFFIX;
+    else before.push({
+      tag: "script",
+      attrs: {
+        nonce,
+        [STREAM_PART_ATTRIBUTE]: ""
+      },
+      children: INITIAL_CLEANUP_SOURCE
+    });
+  }
+  return {
+    before,
+    boundary: {
+      tag: "script",
+      attrs: { nonce },
+      children: HYDRATION_SCRIPT_BOUNDARY_SOURCE
+    }
+  };
+}
+var HydrationScriptsOwner = class {
+  constructor(nonce, initialSources) {
+    this.nonce = nonce;
+    this.queuedSources = [];
+    this.queuedSourceHead = 0;
+    this.initialTaken = false;
+    this.barrierLifted = false;
+    this.producerDone = false;
+    this.retainedSources = 0;
+    this.regularCodeUnits = 0;
+    this.hasOversizedSource = false;
+    this.segmentIndex = 0;
+    this.closingSegmentIndex = 0;
+    this.source = "";
+    this.sourceOffset = 0;
+    this.outputCapacity = MIN_OUTPUT_BYTES;
+    this.outputState = HydrationScriptOutputState.Waiting;
+    this.takeInitialHydrationScriptTags = this.takeInitialHydrationScriptTags.bind(this);
+    const seedSources = initialSources ?? DEFAULT_INITIAL_SOURCES;
+    for (const seedSource of seedSources) {
+      if (!this.account(seedSource)) break;
+      this.queuedSources.push(seedSource);
+    }
+  }
+  get state() {
+    return this.outputState;
+  }
+  get error() {
+    return this.outputError;
+  }
+  notify() {
+    try {
+      this.listener?.();
+    } catch (listenerError) {
+      console.error("Hydration script output listener error:", listenerError);
+    }
+  }
+  refresh(notifyChange = true) {
+    const next = this.outputState === HydrationScriptOutputState.Failed ? HydrationScriptOutputState.Failed : this.active ? HydrationScriptOutputState.Active : typeof this.consumer === "object" && this.initialTaken && this.barrierLifted && !this.queueIsEmpty() ? HydrationScriptOutputState.Ready : this.producerDone && this.initialTaken && this.queueIsEmpty() ? HydrationScriptOutputState.Done : HydrationScriptOutputState.Waiting;
+    if (this.outputState !== next) {
+      this.outputState = next;
+      if (notifyChange) this.notify();
+    }
+  }
+  clearTimeoutIfSet() {
+    if (this.timeout !== void 0) {
+      clearTimeout(this.timeout);
+      this.timeout = void 0;
+    }
+  }
+  queueIsEmpty() {
+    return this.queuedSourceHead === this.queuedSources.length;
+  }
+  clearQueue() {
+    this.queuedSources = [];
+    this.queuedSourceHead = 0;
+  }
+  dropBufferedOutput() {
+    this.clearQueue();
+    this.active = void 0;
+    this.retainedSources = 0;
+    this.regularCodeUnits = 0;
+    this.hasOversizedSource = false;
+    this.segmentIndex = 0;
+    this.closingSegmentIndex = 0;
+    this.source = "";
+    this.sourceOffset = 0;
+    this.outputCapacity = MIN_OUTPUT_BYTES;
+    this.opening = void 0;
+  }
+  fail(reason) {
+    if (this.consumer === "cleaned" || this.outputState === HydrationScriptOutputState.Failed) return;
+    this.outputError = reason;
+    this.clearTimeoutIfSet();
+    this.dropBufferedOutput();
+    this.outputState = HydrationScriptOutputState.Failed;
+    this.notify();
+  }
+  rejectBacklog(kind) {
+    this.fail(/* @__PURE__ */ new Error(`SSR hydration backlog exceeded maximum ${kind} count`));
+    return false;
+  }
+  account(nextSource) {
+    if (this.retainedSources === MAX_BACKLOG_SOURCES) return this.rejectBacklog("source-part");
+    if (nextSource.length > MAX_BACKLOG_CODE_UNITS) {
+      if (this.hasOversizedSource) return this.rejectBacklog("code-unit");
+      this.hasOversizedSource = true;
+    } else if (this.regularCodeUnits + nextSource.length > MAX_BACKLOG_CODE_UNITS) return this.rejectBacklog("code-unit");
+    else this.regularCodeUnits += nextSource.length;
+    this.retainedSources++;
+    return true;
+  }
+  releaseSource(part) {
+    this.retainedSources--;
+    if (part.length > MAX_BACKLOG_CODE_UNITS) this.hasOversizedSource = false;
+    else this.regularCodeUnits -= part.length;
+  }
+  releaseAccounting(batch) {
+    for (const part of batch) if (part !== void 0) this.releaseSource(part);
+  }
+  liftBarrier() {
+    if (this.consumer !== "cleaned" && !this.barrierLifted) {
+      this.barrierLifted = true;
+      this.refresh();
+    }
+  }
+  producerCanWrite() {
+    return this.consumer !== "cleaned" && this.outputState !== HydrationScriptOutputState.Failed && !this.producerDone;
+  }
+  pushSource(nextSource) {
+    if (!this.producerCanWrite()) return false;
+    if (this.account(nextSource)) {
+      this.queuedSources.push(nextSource);
+      if (this.initialTaken) this.refresh();
+    } else return false;
+    return this.producerCanWrite();
+  }
+  takeQueuedBatch(batchLength) {
+    if (this.queuedSourceHead === 0 && batchLength === this.queuedSources.length) {
+      const batch2 = this.queuedSources;
+      this.clearQueue();
+      return batch2;
+    }
+    const end = this.queuedSourceHead + batchLength;
+    const batch = this.queuedSources.slice(this.queuedSourceHead, end);
+    for (let index = this.queuedSourceHead; index < end; index++) this.queuedSources[index] = void 0;
+    this.queuedSourceHead = end;
+    if (this.queueIsEmpty()) this.clearQueue();
+    else if (this.queuedSourceHead >= 1024 && this.queuedSourceHead >= this.queuedSources.length - this.queuedSourceHead) {
+      this.queuedSources = this.queuedSources.slice(this.queuedSourceHead);
+      this.queuedSourceHead = 0;
+    }
+    return batch;
+  }
+  release(batch) {
+    this.releaseAccounting(batch);
+    this.active = void 0;
+    this.source = "";
+    this.sourceOffset = 0;
+    this.refresh(false);
+  }
+  advanceSource() {
+    const batch = this.active;
+    if (this.segmentIndex > 0 && this.segmentIndex < this.closingSegmentIndex) {
+      const partIndex = this.segmentIndex - 1 >> 1;
+      if (this.segmentIndex % 2 === 1) {
+        const part = batch[partIndex];
+        if (part !== void 0) {
+          this.releaseSource(part);
+          batch[partIndex] = void 0;
+        }
+      }
+    }
+    this.segmentIndex++;
+    if (this.segmentIndex < this.closingSegmentIndex) {
+      const partIndex = this.segmentIndex - 1 >> 1;
+      this.source = this.segmentIndex % 2 === 1 ? batch[partIndex] : SOURCE_SEPARATOR;
+    } else if (this.segmentIndex === this.closingSegmentIndex) this.source = DYNAMIC_CLOSE_SOURCE;
+    else this.release(batch);
+    this.sourceOffset = 0;
+  }
+  pullActive() {
+    const bytes = new Uint8Array(this.outputCapacity);
+    let offset = 0;
+    while (this.active) if (this.sourceOffset === this.source.length) this.advanceSource();
+    else if (offset === bytes.length) break;
+    else {
+      const result = encodeIntoBoundedChunk(this.source, this.sourceOffset, bytes, offset);
+      if (result.read === 0) break;
+      this.sourceOffset += result.read;
+      offset += result.written;
+    }
+    if (offset === 0) throw new Error("SSR router script record produced no output");
+    if (offset === bytes.length) return bytes;
+    return offset * 2 < bytes.length ? bytes.slice(0, offset) : bytes.subarray(0, offset);
+  }
+  pullReady() {
+    const scriptOpening = this.opening ??= this.nonce ? `<script nonce="${escapeAttribute(this.nonce)}">` : "<script>";
+    let codeUnits = scriptOpening.length + 40;
+    let batchLength = 0;
+    for (let index = this.queuedSourceHead; index < this.queuedSources.length; index++) {
+      const part = this.queuedSources[index];
+      const nextCodeUnits = codeUnits + 1 + part.length;
+      if (batchLength > 0 && nextCodeUnits > MAX_DYNAMIC_RECORD_CODE_UNITS) break;
+      codeUnits = nextCodeUnits;
+      batchLength++;
+      if (codeUnits > MAX_DYNAMIC_RECORD_CODE_UNITS) break;
+    }
+    const batch = this.takeQueuedBatch(batchLength);
+    if (codeUnits <= MAX_DIRECT_CODE_UNITS) {
+      const joined = batch.length === 1 ? batch[0] : batch.join(SOURCE_SEPARATOR);
+      const bytes = encoder.encode(scriptOpening + joined + ";document.currentScript.remove()</script>");
+      this.release(batch);
+      return bytes;
+    }
+    this.active = batch;
+    this.segmentIndex = 0;
+    this.closingSegmentIndex = (batch.length << 1) + 1;
+    this.source = scriptOpening;
+    this.sourceOffset = 0;
+    this.outputCapacity = Math.max(MIN_OUTPUT_BYTES, Math.min(MAX_HYDRATION_OUTPUT_CHUNK_BYTES, codeUnits));
+    this.outputState = HydrationScriptOutputState.Active;
+    return this.pullActive();
+  }
+  pullChunk() {
+    if (this.outputState !== HydrationScriptOutputState.Ready && this.outputState !== HydrationScriptOutputState.Active) throw new Error("Hydration script output is not ready");
+    try {
+      return this.outputState === HydrationScriptOutputState.Ready ? this.pullReady() : this.pullActive();
+    } catch (cause) {
+      this.fail(cause);
+      throw cause;
+    }
+  }
+  subscribe(onChange) {
+    if (this.consumer === "cleaned") return () => {
+    };
+    if (this.listener) throw new Error("SSR hydration output already has a subscriber");
+    this.listener = onChange;
+    return () => {
+      if (this.listener === onChange) this.listener = void 0;
+    };
+  }
+  pushSerializedSource(data, initial, wrap) {
+    let serialized = initial ? ROUTER_PREFIX + data : data;
+    if (wrap) serialized = PROMISE_PREFIX + serialized + ")";
+    return this.pushSource(serialized);
+  }
+  finish() {
+    if (!this.pushSource("$_TSR.e()")) return;
+    this.producerDone = true;
+    this.clearTimeoutIfSet();
+    this.refresh();
+  }
+  takeInitialHydrationScriptTags() {
+    if (this.consumer === "cleaned" || this.outputState === HydrationScriptOutputState.Failed || this.initialTaken) return;
+    const sources = this.queuedSources;
+    const tags = createInitialTags(sources, this.nonce);
+    this.initialTaken = true;
+    this.releaseAccounting(sources);
+    sources.length = 0;
+    this.queuedSourceHead = 0;
+    this.refresh();
+    return tags;
+  }
+  /**
+  * Opt this request out of hydration output entirely (for example a
+  * `hydrate: false` page). Drops the queued bootstrap sources, marks the
+  * producer done, and makes the fast pass-through path reservable without
+  * a rendered `<Scripts>` boundary. Must run before the initial take and
+  * before serialization produces output.
+  */
+  disableHydration() {
+    if (this.consumer === "cleaned" || this.outputState === HydrationScriptOutputState.Failed) return;
+    if (this.initialTaken || this.consumer !== void 0 || this.producerDone) {
+      if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: hydration output is already committed; disableHydration() must run before <Scripts> renders and before serialization starts.");
+      invariant();
+    }
+    this.releaseAccounting(this.queuedSources);
+    this.clearQueue();
+    this.initialTaken = true;
+    this.barrierLifted = true;
+    this.producerDone = true;
+    this.refresh();
+  }
+  isInitialTaken() {
+    return this.initialTaken;
+  }
+  skipInitialTake() {
+    if (this.consumer !== "cleaned" && !this.initialTaken) {
+      this.initialTaken = true;
+      this.refresh();
+    }
+  }
+  claimOutput() {
+    if (this.consumer === "cleaned") throw new Error("SSR hydration script output is already cleaned up");
+    if (this.consumer !== void 0) throw new Error("SSR hydration script output already has a consumer");
+    this.consumer = this;
+    this.refresh(false);
+    return this;
+  }
+  reserveFastPath(output) {
+    const ownsConsumer = this.consumer === output;
+    if (this.outputState === HydrationScriptOutputState.Failed || !this.producerDone || !this.initialTaken || !this.queueIsEmpty() || this.active || !ownsConsumer) return false;
+    this.consumer = "fast-path";
+    return true;
+  }
+  startSerializationTimeout(timeoutMs) {
+    if (this.consumer === "cleaned" || this.outputState === HydrationScriptOutputState.Failed || this.producerDone || this.timeout !== void 0) return;
+    this.timeout = setTimeout(() => {
+      this.timeout = void 0;
+      if (this.consumer !== "cleaned" && this.outputState !== HydrationScriptOutputState.Failed && !this.producerDone) {
+        console.error("Serialization timeout after app render finished");
+        this.fail(/* @__PURE__ */ new Error("Serialization timeout after app render finished"));
+      }
+    }, timeoutMs);
+  }
+  cleanup() {
+    if (this.consumer === "cleaned") return;
+    this.consumer = "cleaned";
+    this.clearTimeoutIfSet();
+    this.dropBufferedOutput();
+    this.listener = void 0;
+    this.outputError = void 0;
+    this.producerDone = true;
+    this.outputState = HydrationScriptOutputState.Done;
+  }
+};
+function createHydrationScripts(nonce, initialSources) {
+  return new HydrationScriptsOwner(nonce, initialSources);
+}
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/RawStreamSSRPlugin.js
+var nodeBuffer = globalThis.Buffer;
+var toBase64Fast = nodeBuffer ? (bytes) => nodeBuffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64") : toBase64;
+var BINARY_FACTORY = () => {
+};
+var TEXT_FACTORY = () => {
+};
+var FACTORY_BINARY = `((s,u=1)=>new ReadableStream({start(c,f){f=s.on({next(b){const d=atob(b),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)},throw(e){s=u=0;c.error(e)},return(){s=u=0;c.close()}});u=u&&f},cancel(){u&&u()}}))`;
+var FACTORY_TEXT = `((s,u=1,e=new TextEncoder)=>new ReadableStream({start(c,f){f=s.on({next(v){const x=v.slice(1);if(v[0]==='t')c.enqueue(e.encode(x));else{const d=atob(x),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}},throw(x){s=u=0;c.error(x)},return(){s=u=0;c.close()}});u=u&&f},cancel(){u&&u()}}))`;
+function makeFactoryPlugin(tag, sentinel, source) {
+  return createPlugin({
+    tag,
+    test(value) {
+      return value === sentinel;
+    },
+    parse: { stream() {
+      return {};
+    } },
+    serialize() {
+      return source;
+    },
+    deserialize: void 0
+  });
+}
+var RawStreamSSRPlugin = /* @__PURE__ */ createPlugin({
+  tag: "tss/RawStream",
+  extends: [/* @__PURE__ */ makeFactoryPlugin("tss/RawStreamFactory", BINARY_FACTORY, FACTORY_BINARY), /* @__PURE__ */ makeFactoryPlugin("tss/RawStreamFactoryText", TEXT_FACTORY, FACTORY_TEXT)],
+  test(value) {
+    return value instanceof RawStream;
+  },
+  parse: { stream(value, ctx) {
+    const text = value.hint === "text";
+    const factory = ctx.parse(text ? TEXT_FACTORY : BINARY_FACTORY);
+    const [stream, stop] = pumpEncodedStream(value.stream, text ? encodeText : toBase64Fast);
+    ctx.addCleanup(stop);
+    return {
+      factory,
+      stream: ctx.parse(stream)
+    };
+  } },
+  serialize(node, ctx) {
+    return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
+  },
+  deserialize: void 0
+});
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/seroval-plugins.ssr.js
+var ssrSerovalPlugins = [
+  ShallowErrorPlugin,
+  RawStreamSSRPlugin,
+  ReadableStreamPlugin
+];
+
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/ssr-server.js
 function dehydrateMatch(match) {
   const dehydratedMatch = {
     i: dehydrateSsrMatchId(match.id),
@@ -56,98 +879,38 @@ function dehydrateMatch(match) {
   if (match._notFound) dehydratedMatch.g = true;
   return dehydratedMatch;
 }
-var INITIAL_SCRIPTS = [getCrossReferenceHeader(SCOPE_ID), tsrScript_default];
-var ScriptBuffer = class {
-  constructor(injectScript) {
-    this._scriptBarrierLifted = false;
-    this._cleanedUp = false;
-    this._microtaskVersion = 0;
-    this._pendingMicrotaskVersion = 0;
-    this.injectScript = injectScript;
-    this._queue = INITIAL_SCRIPTS.slice();
-  }
-  enqueue(script) {
-    if (this._cleanedUp) return;
-    this._queue.push(script);
-    if (this._scriptBarrierLifted) this.scheduleInjectBufferedScripts();
-  }
-  liftBarrier() {
-    if (this._scriptBarrierLifted || this._cleanedUp) return;
-    this._scriptBarrierLifted = true;
-    if (this._queue.length > 0) this.scheduleInjectBufferedScripts();
-  }
-  scheduleInjectBufferedScripts() {
-    if (this._pendingMicrotaskVersion !== 0) return;
-    const pendingVersion = ++this._microtaskVersion;
-    this._pendingMicrotaskVersion = pendingVersion;
-    queueMicrotask(() => {
-      if (this._pendingMicrotaskVersion !== pendingVersion) return;
-      this._pendingMicrotaskVersion = 0;
-      this.injectBufferedScripts();
-    });
-  }
-  clearPendingMicrotask() {
-    if (this._pendingMicrotaskVersion === 0) return;
-    this._pendingMicrotaskVersion = 0;
-    this._microtaskVersion++;
-  }
-  /**
-  * Flushes any pending scripts synchronously.
-  * Call this before signaling serialization finished to ensure all scripts are injected.
-  *
-  * IMPORTANT: Only injects if the barrier has been lifted. Before the barrier is lifted,
-  * scripts should remain in the queue so takeBufferedScripts() can retrieve them
-  */
-  flush() {
-    if (!this._scriptBarrierLifted) return;
-    if (this._cleanedUp) return;
-    this.clearPendingMicrotask();
-    this.injectBufferedScripts();
-  }
-  takeAll() {
-    return this.takeScripts(this._queue.length);
-  }
-  takeScripts(count) {
-    if (count <= 0) return void 0;
-    const bufferedScripts = this._queue.splice(0, count);
-    if (bufferedScripts.length === 0) return;
-    if (bufferedScripts.length === 1) return bufferedScripts[0] + ";document.currentScript.remove()";
-    return bufferedScripts.join(";") + ";document.currentScript.remove()";
-  }
-  hasPending() {
-    return this._queue.length > 0;
-  }
-  injectBufferedScripts() {
-    if (this._cleanedUp) return;
-    if (this._queue.length === 0) return;
-    const scriptsToInject = this.takeAll();
-    if (scriptsToInject) this.injectScript?.(scriptsToInject);
+function disposeSerializationSafely(dispose) {
+  try {
+    dispose?.();
+  } catch (err) {
+    console.error("Error disposing SSR serialization:", err);
   }
-  cleanup() {
-    this._cleanedUp = true;
-    this.clearPendingMicrotask();
-    this._queue = [];
-    this.injectScript = void 0;
+}
+function notifyAndClearListeners(listeners, errorMessage, arg) {
+  const pending = listeners.slice();
+  listeners.length = 0;
+  for (const listener of pending) try {
+    listener(arg);
+  } catch (error) {
+    console.error(errorMessage, error);
   }
-};
+}
 var isProd = process.env.NODE_ENV === "production";
 var MANIFEST_CACHE_SIZE = 100;
 var manifestCaches = /* @__PURE__ */ new WeakMap();
 function getManifestCache(manifest2) {
   const cache = manifestCaches.get(manifest2);
   if (cache) return cache;
-  const newCache = createLRUCache(MANIFEST_CACHE_SIZE);
+  const newCache = createSieveCache(MANIFEST_CACHE_SIZE);
   manifestCaches.set(manifest2, newCache);
   return newCache;
 }
 function getInlineCssForPreparedRoutes(manifest2, preparedRoutes) {
-  if (preparedRoutes.inlineCss !== void 0) return preparedRoutes.inlineCss;
   const styles = manifest2.inlineCss?.styles;
   const hrefs = preparedRoutes.inlineCssHrefs;
-  if (!styles || !hrefs?.length) return void 0;
+  if (!styles || !hrefs?.length) return;
   let css = "";
   for (const href of hrefs) css += styles[href];
-  preparedRoutes.inlineCss = css;
   return css;
 }
 function getInlineCssAssetForPreparedRoutes(manifest2, preparedRoutes) {
@@ -246,78 +1009,69 @@ function mergeRequestAssetsIntoRootRoute(rootRoute, requestAssets) {
     ...cssLinks?.length ? { css: cssLinks } : {}
   };
 }
+function composeManifest(scriptFormat, inlineStyle, routes, requestAssets) {
+  const base = {
+    ...scriptFormat ? { scriptFormat } : {},
+    ...inlineStyle ? { inlineStyle } : {},
+    routes
+  };
+  if (!hasRequestAssets(requestAssets)) return base;
+  return {
+    ...base,
+    routes: {
+      ...routes,
+      [rootRouteId]: mergeRequestAssetsIntoRootRoute(routes[rootRouteId], requestAssets)
+    }
+  };
+}
 function attachRouterServerSsrUtils({ router, manifest: manifest2, getRequestAssets }) {
+  let memoizedPreparedManifest;
   router.ssr = { get manifest() {
     if (!manifest2) return manifest2;
     const requestAssets = getRequestAssets?.();
-    const matches = _getRenderedMatches(router.stores.matches.get());
     const hasAssets = hasRequestAssets(requestAssets);
     if (!hasAssets && !manifest2.inlineCss) return manifest2;
     let inlineCssAsset;
     let routes = manifest2.routes;
     if (manifest2.inlineCss) {
-      const preparedManifest = getPreparedMatchedManifestRoutes(manifest2, matches, getMatchedRoutesCacheKey(matches));
-      inlineCssAsset = getInlineCssAssetForPreparedRoutes(manifest2, preparedManifest);
-      if (preparedManifest.hasStrippedRoutes) routes = {
-        ...manifest2.routes,
-        ...preparedManifest.routes
-      };
-    }
-    if (!hasAssets) return {
-      ...manifest2.scriptFormat ? { scriptFormat: manifest2.scriptFormat } : {},
-      ...inlineCssAsset ? { inlineStyle: inlineCssAsset } : {},
-      routes
-    };
-    const rootRoute = routes[rootRouteId];
-    return {
-      ...manifest2.scriptFormat ? { scriptFormat: manifest2.scriptFormat } : {},
-      ...inlineCssAsset ? { inlineStyle: inlineCssAsset } : {},
-      routes: {
-        ...routes,
-        [rootRouteId]: mergeRequestAssetsIntoRootRoute(rootRoute, requestAssets)
+      const matches = _getRenderedMatches(router.stores.matches.get());
+      const cacheKey = getMatchedRoutesCacheKey(matches);
+      if (memoizedPreparedManifest?.cacheKey === cacheKey) {
+        inlineCssAsset = memoizedPreparedManifest.inlineCssAsset;
+        routes = memoizedPreparedManifest.routes;
+      } else {
+        const preparedManifest = getPreparedMatchedManifestRoutes(manifest2, matches, cacheKey);
+        inlineCssAsset = getInlineCssAssetForPreparedRoutes(manifest2, preparedManifest);
+        if (preparedManifest.hasStrippedRoutes) routes = {
+          ...manifest2.routes,
+          ...preparedManifest.routes
+        };
+        memoizedPreparedManifest = {
+          cacheKey,
+          inlineCssAsset,
+          routes
+        };
       }
-    };
+    }
+    return composeManifest(manifest2.scriptFormat, inlineCssAsset, routes, hasAssets ? requestAssets : void 0);
   } };
-  let _dehydrated = false;
-  let _serializationFinished = false;
-  let streamFastPathReserved = false;
+  let dehydrationPhase = "idle";
+  let renderFinished = false;
   const renderFinishedListeners = [];
-  const injectedHtmlListeners = [];
-  const serializationFinishedListeners = [];
   const cleanupListeners = [];
   let cleanupStarted = false;
-  let injectedHtmlBuffer = "";
-  const callListeners = (listeners, errorPrefix) => {
-    const snapshot = listeners.slice();
-    for (const l of snapshot) try {
-      l();
-    } catch (err) {
-      console.error(`${errorPrefix}:`, err);
-    }
-  };
-  const removeListener = (listeners, listener) => {
-    const index = listeners.indexOf(listener);
-    if (index >= 0) listeners.splice(index, 1);
-  };
-  const scriptBuffer = new ScriptBuffer((script) => {
-    serverSsr.injectScript(script);
-  });
+  let settled = false;
+  let disposeSerialization;
+  const hydrationScripts = createHydrationScripts(router.options.ssr?.nonce);
   const serverSsr = {
-    injectHtml: (html) => {
-      if (!html || cleanupStarted) return;
-      injectedHtmlBuffer += html;
-      callListeners(injectedHtmlListeners, "SSR injected HTML listener error");
-    },
-    injectScript: (script) => {
-      if (!script || cleanupStarted) return;
-      const html = `<script${router.options.ssr?.nonce ? ` nonce='${router.options.ssr.nonce}'` : ""}>${script}</script>`;
-      serverSsr.injectHtml(html);
-    },
+    hydrationScripts,
     dehydrate: async (opts) => {
-      if (_dehydrated) {
-        if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: router is already dehydrated!");
+      if (dehydrationPhase !== "idle") {
+        if (process.env.NODE_ENV !== "production") throw new Error(dehydrationPhase === "disabled" ? "Invariant failed: hydration is disabled for this request!" : "Invariant failed: router is already dehydrated!");
         invariant();
       }
+      opts?.signal?.throwIfAborted();
+      dehydrationPhase = "started";
       let matchesToDehydrate = _getRenderedMatches(router.stores.matches.get());
       if (router.isShell()) matchesToDehydrate = matchesToDehydrate.slice(0, 1);
       const matches = matchesToDehydrate.map(dehydrateMatch);
@@ -325,160 +1079,106 @@ function attachRouterServerSsrUtils({ router, manifest: manifest2, getRequestAss
       if (manifest2) {
         const cacheKey = getMatchedRoutesCacheKey(matchesToDehydrate);
         const preparedManifest = getPreparedMatchedManifestRoutes(manifest2, matchesToDehydrate, cacheKey);
-        manifestToDehydrate = {
-          ...manifest2.scriptFormat ? { scriptFormat: manifest2.scriptFormat } : {},
-          ...preparedManifest.inlineCssHrefs ? { inlineStyle: createInlineCssPlaceholderAsset() } : {},
-          routes: preparedManifest.routes
-        };
-        const requestAssets = opts?.requestAssets;
-        if (hasRequestAssets(requestAssets)) {
-          const existingRoot = manifestToDehydrate.routes[rootRouteId];
-          manifestToDehydrate.routes = {
-            ...manifestToDehydrate.routes,
-            [rootRouteId]: mergeRequestAssetsIntoRootRoute(existingRoot, requestAssets)
-          };
-        }
+        manifestToDehydrate = composeManifest(manifest2.scriptFormat, preparedManifest.inlineCssHrefs ? createInlineCssPlaceholderAsset() : void 0, preparedManifest.routes, opts?.requestAssets);
       }
       const dehydratedRouter = {
         manifest: manifestToDehydrate,
         matches
       };
-      const dehydratedData = await router.options.dehydrate?.();
+      const dehydrate = router.options.dehydrate;
+      const dehydratedData = dehydrate ? opts?.signal ? await waitForReason(dehydrate.call(router.options), opts.signal) : await dehydrate.call(router.options) : void 0;
+      opts?.signal?.throwIfAborted();
       if (cleanupStarted) return;
-      if (dehydratedData) dehydratedRouter.dehydratedData = dehydratedData;
-      _dehydrated = true;
+      if (dehydratedData !== void 0) dehydratedRouter.dehydratedData = dehydratedData;
       const trackPlugins = { didRun: false };
       const serializationAdapters = router.options.serializationAdapters;
-      const plugins = serializationAdapters ? serializationAdapters.map((t) => /* @__PURE__ */ makeSsrSerovalPlugin(t, trackPlugins)).concat(defaultSerovalPlugins) : defaultSerovalPlugins;
+      const plugins = serializationAdapters ? [...serializationAdapters.map((adapter) => /* @__PURE__ */ makeSsrSerovalPlugin(adapter, trackPlugins)), ...ssrSerovalPlugins] : ssrSerovalPlugins;
       let serializationCompleteSignaled = false;
-      const signalSerializationComplete = () => {
+      let initialSerialized = false;
+      const completeScriptSerialization = (result) => {
         if (serializationCompleteSignaled || cleanupStarted) return;
         serializationCompleteSignaled = true;
-        _serializationFinished = true;
-        const listeners = serializationFinishedListeners.slice();
-        serializationFinishedListeners.length = 0;
-        for (const l of listeners) try {
-          l();
-        } catch (err) {
-          console.error("Serialization listener error:", err);
-        }
-      };
-      const finishScriptSerialization = () => {
-        if (serializationCompleteSignaled || cleanupStarted) return;
-        scriptBuffer.enqueue(GLOBAL_TSR + ".e()");
-        scriptBuffer.flush();
-        signalSerializationComplete();
+        const dispose2 = disposeSerialization;
+        disposeSerialization = void 0;
+        if (result === true) {
+          settled = true;
+          hydrationScripts.finish();
+        } else if (result) hydrationScripts.fail(result.error);
+        if (dispose2) queueMicrotask(() => disposeSerializationSafely(dispose2));
       };
-      crossSerializeStream(dehydratedRouter, {
+      let synchronousFailure;
+      const dispose = crossSerializeStream(dehydratedRouter, {
         refs: /* @__PURE__ */ new Map(),
         plugins,
         onSerialize: (data, initial) => {
-          let serialized = initial ? TSR_PREFIX + data : data;
-          if (trackPlugins.didRun) serialized = P_PREFIX + serialized + P_SUFFIX;
-          scriptBuffer.enqueue(serialized);
+          if (serializationCompleteSignaled || cleanupStarted) return;
+          initialSerialized ||= initial;
+          if (!hydrationScripts.pushSerializedSource(data, initial, trackPlugins.didRun)) completeScriptSerialization(false);
         },
         onError: (err) => {
+          if (serializationCompleteSignaled || cleanupStarted) return;
           console.error("Serialization error:", err);
-          if (err && err.stack) console.error(err.stack);
-          finishScriptSerialization();
+          synchronousFailure = { error: err };
+          completeScriptSerialization({ error: err });
         },
-        scopeId: SCOPE_ID,
+        scopeId: "tsr",
         onDone: () => {
-          finishScriptSerialization();
+          if (initialSerialized) completeScriptSerialization(true);
         }
       });
-    },
-    isDehydrated() {
-      return _dehydrated;
-    },
-    isSerializationFinished() {
-      return _serializationFinished;
-    },
-    reserveStreamFastPath() {
-      if (!cleanupStarted && _serializationFinished && !streamFastPathReserved && renderFinishedListeners.length === 0 && !injectedHtmlBuffer && !scriptBuffer.hasPending()) {
-        streamFastPathReserved = true;
-        return true;
-      }
-      return false;
-    },
-    onInjectedHtml: (listener) => {
-      if (cleanupStarted) return () => {
-      };
-      injectedHtmlListeners.push(listener);
-      return () => removeListener(injectedHtmlListeners, listener);
+      if (cleanupStarted || serializationCompleteSignaled) disposeSerializationSafely(dispose);
+      else disposeSerialization = dispose;
+      if (synchronousFailure) throw synchronousFailure.error;
     },
     onRenderFinished: (listener) => {
-      if (cleanupStarted || streamFastPathReserved) return;
-      renderFinishedListeners.push(listener);
-    },
-    onSerializationFinished: (listener) => {
-      if (cleanupStarted) return () => {
-      };
-      if (_serializationFinished && !cleanupStarted) {
+      if (cleanupStarted) return;
+      if (renderFinished) {
         try {
           listener();
-        } catch (err) {
-          console.error("Serialization listener error:", err);
+        } catch (error) {
+          console.error("Error in render finished listener:", error);
         }
-        return () => {
-        };
+        return;
       }
-      serializationFinishedListeners.push(listener);
-      return () => removeListener(serializationFinishedListeners, listener);
+      renderFinishedListeners.push(listener);
     },
     onCleanup: (listener) => {
-      if (cleanupStarted) return;
+      if (cleanupStarted) {
+        try {
+          listener(settled);
+        } catch (error) {
+          console.error("Error in SSR cleanup listener:", error);
+        }
+        return;
+      }
       cleanupListeners.push(listener);
     },
     setRenderFinished: () => {
-      if (cleanupStarted) return;
-      scriptBuffer.liftBarrier();
-      const listeners = renderFinishedListeners.slice();
-      renderFinishedListeners.length = 0;
-      for (const l of listeners) try {
-        l();
-      } catch (err) {
-        console.error("Error in render finished listener:", err);
-      }
-      if (_serializationFinished) scriptBuffer.flush();
-    },
-    takeBufferedScripts() {
-      const scripts = scriptBuffer.takeAll();
-      if (!scripts) return void 0;
-      return {
-        tag: "script",
-        attrs: {
-          nonce: router.options.ssr?.nonce,
-          className: "$tsr",
-          id: TSR_SCRIPT_BARRIER_ID
-        },
-        children: scripts
-      };
-    },
-    liftScriptBarrier() {
-      scriptBuffer.liftBarrier();
+      if (cleanupStarted || renderFinished) return;
+      renderFinished = true;
+      hydrationScripts.liftBarrier();
+      notifyAndClearListeners(renderFinishedListeners, "Error in render finished listener:", void 0);
     },
-    takeBufferedHtml() {
-      if (!injectedHtmlBuffer) return;
-      const buffered = injectedHtmlBuffer;
-      injectedHtmlBuffer = "";
-      return buffered;
+    disableHydration: () => {
+      if (cleanupStarted || dehydrationPhase === "disabled") return;
+      if (dehydrationPhase !== "idle") {
+        if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: cannot disable hydration after dehydrate()!");
+        invariant();
+      }
+      hydrationScripts.disableHydration();
+      dehydrationPhase = "disabled";
     },
+    takeInitialHydrationScriptTags: hydrationScripts.takeInitialHydrationScriptTags,
     cleanup() {
       if (cleanupStarted) return;
       cleanupStarted = true;
-      const listeners = cleanupListeners.slice();
-      cleanupListeners.length = 0;
-      for (const l of listeners) try {
-        l();
-      } catch (err) {
-        console.error("Error in SSR cleanup listener:", err);
-      }
+      hydrationScripts.cleanup();
+      const dispose = disposeSerialization;
+      disposeSerialization = void 0;
+      disposeSerializationSafely(dispose);
+      notifyAndClearListeners(cleanupListeners, "Error in SSR cleanup listener:", settled);
       renderFinishedListeners.length = 0;
-      injectedHtmlListeners.length = 0;
-      serializationFinishedListeners.length = 0;
-      injectedHtmlBuffer = "";
-      scriptBuffer.cleanup();
+      router.ssr = void 0;
       router.serverSsr = void 0;
     }
   };
@@ -489,17 +1189,11 @@ function attachRouterServerSsrUtils({ router, manifest: manifest2, getRequestAss
     console.error("SSR attach listener error:", err);
   }
 }
-function getOrigin(request) {
-  try {
-    return new URL(request.url).origin;
-  } catch {
-  }
-  return "http://localhost";
-}
 function getNormalizedURL(url, base) {
   if (typeof url === "string") url = url.replace("\\", "%5C");
   const rawUrl = new URL(url, base);
-  const { path: decodedPathname, handledProtocolRelativeURL } = decodePath(rawUrl.pathname);
+  const handledProtocolRelativeURL = rawUrl.pathname.startsWith("//");
+  const decodedPathname = decodePath(handledProtocolRelativeURL ? rawUrl.pathname.replace(/^\/+/, "/") : rawUrl.pathname);
   const searchParams = new URLSearchParams(rawUrl.search);
   const normalizedHref = decodedPathname + (searchParams.size > 0 ? "?" : "") + searchParams.toString() + rawUrl.hash;
   return {
@@ -508,7 +1202,7 @@ function getNormalizedURL(url, base) {
   };
 }
 
-// node_modules/.pnpm/@tanstack+router-core@1.171.27/node_modules/@tanstack/router-core/dist/esm/ssr/handlerCallback.js
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/handlerCallback.js
 function isSsrResponse(value) {
   return typeof value === "object" && value !== null && "response" in value && "serverSsrCleanup" in value;
 }
@@ -518,76 +1212,69 @@ function normalizeSsrResponse(result) {
     serverSsrCleanup: "none"
   };
 }
-function disposeSsrResponse(response, reason) {
-  if (response.serverSsrCleanup !== "stream") return Promise.resolve();
-  try {
-    return Promise.resolve(response.dispose(reason));
-  } catch (error) {
-    return Promise.reject(error);
-  }
+function cancelResponseBody(response, reason) {
+  const body = response.body;
+  if (!body) return;
+  body.cancel(reason).catch(console.error);
 }
-function disposeSsrResponseDetached(result, reason, onError2 = console.error) {
-  const ssrResponse = normalizeSsrResponse(result);
-  if (ssrResponse.serverSsrCleanup === "stream") {
-    disposeSsrResponse(ssrResponse, reason).catch(onError2);
-    return;
-  }
-  if (ssrResponse.response.body) try {
-    ssrResponse.response.body.cancel(reason).catch(onError2);
-  } catch (error) {
-    onError2(error);
-  }
+function disposeSsrResponse(result, reason) {
+  const response = normalizeSsrResponse(result);
+  if (response.serverSsrCleanup === "stream") response.dispose(reason);
+  else cancelResponseBody(response.response, reason);
+}
+function getSsrStatus(router) {
+  return router._serverResult?.type === "render" ? router._serverResult.status : 200;
 }
 function createSsrStreamResponse(router, response) {
-  if (!response.body) throw new Error("Invariant failed: SSR stream response requires a body");
-  let disposed = false;
+  const body = response.body;
+  if (!body) throw new Error("Invariant failed: SSR stream response requires a body");
   return {
     response,
     serverSsrCleanup: "stream",
-    async dispose(reason) {
-      if (disposed) return;
-      disposed = true;
+    dispose(reason) {
       router.serverSsr?.cleanup();
-      try {
-        await response.body.cancel(reason);
-      } catch {
-      }
+      body.cancel(reason).catch(() => {
+      });
     }
   };
 }
 function bindSsrResponseToRequest(router, result, signal) {
   const ssrResponse = normalizeSsrResponse(result);
   if (ssrResponse.serverSsrCleanup !== "stream") {
-    if (signal.aborted) disposeSsrResponseDetached(result, signal.reason);
+    if (signal.aborted) disposeSsrResponse(result, signal.reason);
     return ssrResponse;
   }
-  const failed = (error) => {
-    router?.serverSsr?.cleanup();
-    console.error(error);
-  };
   const abort = () => {
-    disposeSsrResponseDetached(ssrResponse, signal.reason, failed);
+    disposeSsrResponse(ssrResponse, signal.reason);
   };
   if (signal.aborted) {
     abort();
     return ssrResponse;
   }
+  const serverSsr = router?.serverSsr;
+  if (serverSsr?.hydrationScripts.requestSignal === signal) {
+    serverSsr.onCleanup(() => {
+      if (signal.aborted) abort();
+    });
+    return ssrResponse;
+  }
   signal.addEventListener("abort", abort, { once: true });
-  router?.serverSsr?.onCleanup(() => {
+  if (!serverSsr) return ssrResponse;
+  serverSsr.onCleanup(() => {
     signal.removeEventListener("abort", abort);
   });
   return ssrResponse;
 }
-async function replaceSsrResponse(result, response, reason) {
-  await disposeSsrResponse(normalizeSsrResponse(result), reason);
+function replaceSsrResponse(result, response, reason) {
+  disposeSsrResponse(result, reason);
   return {
     response,
     serverSsrCleanup: "none"
   };
 }
-async function stripSsrResponseBody(result, reason) {
+function stripSsrResponseBody(result, reason) {
   const ssrResponse = normalizeSsrResponse(result);
-  await disposeSsrResponse(ssrResponse, reason);
+  disposeSsrResponse(ssrResponse, reason);
   return {
     response: new Response(null, ssrResponse.response),
     serverSsrCleanup: "none"
@@ -640,7 +1327,7 @@ function splitSetCookieString(cookiesString) {
   return cookiesStrings;
 }
 
-// node_modules/.pnpm/@tanstack+router-core@1.171.27/node_modules/@tanstack/router-core/dist/esm/ssr/headers.js
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/headers.js
 function toHeadersInstance(init) {
   if (init instanceof Headers) return init;
   else if (Array.isArray(init)) return new Headers(init);
@@ -657,647 +1344,490 @@ function mergeHeaders(...headers) {
   }, new Headers());
 }
 
-// node_modules/.pnpm/@tanstack+router-core@1.171.27/node_modules/@tanstack/router-core/dist/esm/ssr/createRequestHandler.js
-var requestWaiters = /* @__PURE__ */ new WeakMap();
-function removeRequestWaiter(waiters, index, reject) {
-  if (waiters[index] !== reject) return;
-  if (index !== waiters.length - 1) {
-    waiters[index] = void 0;
-    return;
-  }
-  waiters.pop();
-  while (waiters.length && waiters[waiters.length - 1] === void 0) waiters.pop();
-}
-function waitForRequest(value, signal, onLate) {
-  const promise = Promise.resolve(value);
-  if (signal.aborted) {
-    promise.then(onLate, () => {
-    });
-    return Promise.reject(signal.reason);
-  }
-  return new Promise((resolve, reject) => {
-    let waiters = requestWaiters.get(signal);
-    let index;
-    if (waiters) index = waiters.push(reject) - 1;
-    else {
-      const newWaiters = [reject];
-      waiters = newWaiters;
-      index = 0;
-      requestWaiters.set(signal, newWaiters);
-      signal.addEventListener("abort", () => {
-        requestWaiters.delete(signal);
-        for (const rejectWaiter of newWaiters) rejectWaiter?.(signal.reason);
-        newWaiters.length = 0;
-      }, { once: true });
-    }
-    promise.then((result) => {
-      removeRequestWaiter(waiters, index, reject);
-      if (signal.aborted) onLate?.(result);
-      else resolve(result);
-    }, (error) => {
-      removeRequestWaiter(waiters, index, reject);
-      reject(error);
-    });
-  });
-}
-
-// node_modules/.pnpm/@tanstack+router-core@1.171.27/node_modules/@tanstack/router-core/dist/esm/ssr/transformStreamWithRouter.js
-import { ReadableStream as ReadableStream2 } from "node:stream/web";
-import { Readable } from "node:stream";
-function transformReadableStreamWithRouter(router, routerStream, opts) {
-  return transformStreamWithRouter(router, routerStream, opts);
-}
-function transformPipeableStreamWithRouter(router, routerStream, opts) {
-  return Readable.fromWeb(transformStreamWithRouter(router, Readable.toWeb(routerStream), opts));
-}
-var MIN_CLOSING_TAG_LENGTH = 4;
+// node_modules/.pnpm/@tanstack+router-core@1.171.33/node_modules/@tanstack/router-core/dist/esm/ssr/transformStreamWithRouter.js
 var DEFAULT_SERIALIZATION_TIMEOUT_MS = 6e4;
-var DEFAULT_LIFETIME_TIMEOUT_MS = DEFAULT_SERIALIZATION_TIMEOUT_MS * 2;
-var MAX_LEFTOVER_CHARS = 2048;
-var MAX_TAIL_CHARS = 64 * 1024;
-var MAX_ROUTER_HTML_CHARS = 16 * 1024 * 1024;
-var MAX_PENDING_WRITE_CHARS = 16 * 1024 * 1024;
-var MergeState = {
-  ReadingBody: 0,
-  HoldingTail: 1,
-  AppDone: 2,
-  Draining: 3,
-  Done: 4
+var MIN_APPLICATION_STRING_CHUNK_BYTES = 256;
+var MAX_APPLICATION_STRING_CHUNK_BYTES = 64 * 1024;
+var ApplicationPhase = {
+  BeforeBoundary: 0,
+  Merge: 1,
+  HeldClose: 2,
+  PassThrough: 3
 };
-var textEncoder = new TextEncoder();
-var noop = () => {
-};
-var resolvedPromise = Promise.resolve();
-function findHtmlBoundary(str) {
-  let lastClosingTagEnd = -1;
-  let searchFrom = str.length - MIN_CLOSING_TAG_LENGTH;
-  while (searchFrom >= 0) {
-    const openSlash = str.lastIndexOf("</", searchFrom);
-    if (openSlash === -1) break;
-    if ((str.charCodeAt(openSlash + 2) | 32) === 98 && (str.charCodeAt(openSlash + 3) | 32) === 111 && (str.charCodeAt(openSlash + 4) | 32) === 100 && (str.charCodeAt(openSlash + 5) | 32) === 121 && str.charCodeAt(openSlash + 6) === 62) return -openSlash - 2;
-    if (lastClosingTagEnd === -1) {
-      let i = openSlash + 2;
-      const startCode = str.charCodeAt(i);
-      if (startCode >= 97 && startCode <= 122 || startCode >= 65 && startCode <= 90) {
-        i++;
-        while (i < str.length) {
-          const code = str.charCodeAt(i);
-          if (code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95 || code === 58 || code === 46 || code === 45) i++;
-          else break;
-        }
-        if (str.charCodeAt(i) === 62) lastClosingTagEnd = i + 1;
-      }
-    }
-    searchFrom = openSlash - 1;
-  }
-  return lastClosingTagEnd;
-}
-function safeReleaseReader(reader) {
+function releaseReader(reader) {
   try {
     reader.releaseLock();
-    return true;
   } catch {
-    return false;
   }
 }
-function safeCancelReader(reader, reason) {
-  let cancelPromise;
+function cancelReader(reader, reason) {
+  const cancelled = reader.cancel(reason).catch(() => {
+  });
+  releaseReader(reader);
+  return cancelled;
+}
+function finalizeSsrStream(kind, reason, controller, reader, serverSsr, onAbort) {
   try {
-    cancelPromise = reader.cancel(reason);
+    if (kind === "complete") controller.close();
+    else if (kind === "failure") controller.error(reason);
   } catch {
   }
-  if (!safeReleaseReader(reader) && cancelPromise) return cancelPromise.then(noop, noop).then(() => {
-    safeReleaseReader(reader);
-  });
-  return cancelPromise ? cancelPromise.then(noop, noop) : resolvedPromise;
+  const aborted = kind !== "complete";
+  if (aborted) try {
+    onAbort?.(reason);
+  } catch {
+  }
+  const readerDone = aborted ? cancelReader(reader, reason) : releaseReader(reader);
+  serverSsr.cleanup();
+  return readerDone;
 }
-function createReaderState(appStream) {
-  const reader = appStream.getReader();
-  let released = false;
-  return {
-    reader,
-    cancel: (reason) => {
-      if (released) return resolvedPromise;
-      released = true;
-      return safeCancelReader(reader, reason);
-    },
-    release: () => {
-      if (released) return;
-      released = true;
-      safeReleaseReader(reader);
-    }
-  };
+function getLifetimeMs(opts) {
+  return opts?.lifetimeMs ?? (opts?.timeoutMs ?? DEFAULT_SERIALIZATION_TIMEOUT_MS) * 2;
 }
-function createAbortNotifier(opts) {
-  let abortNotified = false;
-  return (reason) => {
-    if (abortNotified) return;
-    abortNotified = true;
-    try {
-      opts?.onAbort?.(reason);
-    } catch {
-    }
-  };
+function createCleanupAbortError() {
+  const error = /* @__PURE__ */ new Error("SSR stream transform aborted by router SSR cleanup");
+  error.name = "AbortError";
+  return error;
 }
-function listenToAbort(signal, onAbort) {
+function listenForAbort(signal, onAbort) {
   if (!signal) return;
-  if (signal.aborted) {
-    onAbort(signal.reason);
-    return;
-  }
   const listener = () => onAbort(signal.reason);
   signal.addEventListener("abort", listener, { once: true });
   return () => signal.removeEventListener("abort", listener);
 }
-function transformStreamWithRouter(router, appStream, opts) {
-  const serverSsr = router.serverSsr;
-  if (!serverSsr) throw new Error("Invariant failed: router.serverSsr is required");
-  if (serverSsr.reserveStreamFastPath()) return makeFastPathStream(appStream, opts, serverSsr);
-  return makeMainStream(serverSsr, appStream, opts);
+function setUnrefTimeout(callback, timeoutMs) {
+  const handle = setTimeout(callback, timeoutMs);
+  handle.unref?.();
+  return handle;
 }
-function makeFastPathStream(appStream, opts, serverSsr) {
-  let cleanedUp = false;
-  let controller;
-  let state = MergeState.ReadingBody;
+function armStreamLifecycle(serverSsr, opts, isTerminal, terminate) {
+  const signal = opts?.signal;
   let lifetimeTimeoutHandle;
-  let stopListeningToAbort;
-  let stopListeningToInjectedHtml;
-  const readerState = createReaderState(appStream);
-  const notifyAbort = createAbortNotifier(opts);
-  const isDone = () => state === MergeState.Done;
-  let renderFinished = false;
-  const finishSsrRendering = () => {
-    if (!serverSsr || renderFinished) return true;
-    renderFinished = true;
-    try {
-      serverSsr.setRenderFinished();
-      return true;
-    } catch (error) {
-      safeError(error);
-      cleanup(error);
-      return false;
-    }
-  };
-  const cleanup = (reason, cancelReader = true) => {
-    if (cleanedUp) return resolvedPromise;
-    cleanedUp = true;
+  let stopAbortListener;
+  const disarm = () => {
+    stopAbortListener?.();
+    stopAbortListener = void 0;
+    if (signal && serverSsr.hydrationScripts.requestSignal === signal) serverSsr.hydrationScripts.requestSignal = void 0;
     if (lifetimeTimeoutHandle !== void 0) {
       clearTimeout(lifetimeTimeoutHandle);
       lifetimeTimeoutHandle = void 0;
     }
-    stopListeningToAbort?.();
-    stopListeningToAbort = void 0;
-    try {
-      stopListeningToInjectedHtml?.();
-    } catch {
-    }
-    stopListeningToInjectedHtml = void 0;
-    if (cancelReader) notifyAbort(reason);
-    const readerDone = cancelReader ? readerState.cancel(reason) : (readerState.release(), resolvedPromise);
-    if (serverSsr) try {
-      serverSsr.cleanup();
-    } catch (error) {
-      console.error("Error in SSR cleanup:", error);
-    }
-    return readerDone;
-  };
-  const safeClose = () => {
-    if (isDone()) return;
-    state = MergeState.Done;
-    try {
-      controller?.close();
-    } catch {
-    }
-  };
-  const safeError = (error) => {
-    if (isDone()) return;
-    state = MergeState.Done;
-    try {
-      controller?.error(error);
-    } catch {
-    }
   };
-  if (serverSsr) stopListeningToInjectedHtml = serverSsr.onInjectedHtml(() => {
-    const err = /* @__PURE__ */ new Error("SSR router HTML injected during fast path");
-    safeError(err);
-    cleanup(err);
-  });
-  const lifetimeMs = opts?.lifetimeMs ?? DEFAULT_LIFETIME_TIMEOUT_MS;
-  lifetimeTimeoutHandle = setTimeout(() => {
-    if (!cleanedUp && !isDone()) {
-      const err = /* @__PURE__ */ new Error("Stream lifetime exceeded");
-      console.warn(`SSR stream transform exceeded maximum lifetime (${lifetimeMs}ms), forcing cleanup`);
-      safeError(err);
-      cleanup(err);
-    }
+  const lifetimeMs = getLifetimeMs(opts);
+  lifetimeTimeoutHandle = setUnrefTimeout(() => {
+    if (isTerminal()) return;
+    const error = /* @__PURE__ */ new Error("Stream lifetime exceeded");
+    console.warn(`SSR stream transform exceeded maximum lifetime (${lifetimeMs}ms), forcing cleanup`);
+    terminate("failure", error);
   }, lifetimeMs);
-  const stream = new ReadableStream2({
-    start(c) {
-      controller = c;
-    },
-    async pull(c) {
-      if (cleanedUp || isDone()) return;
-      try {
-        const { done, value } = await readerState.reader.read();
-        if (!done) {
-          if (!cleanedUp && !isDone()) c.enqueue(value);
-          return;
-        }
-        if (cleanedUp || isDone()) return;
-        if (!finishSsrRendering()) return;
-        safeClose();
-        return cleanup(void 0, false);
-      } catch (error) {
-        if (cleanedUp) return;
-        console.error("Error reading appStream:", error);
-        if (state < MergeState.AppDone) try {
-          serverSsr?.setRenderFinished();
-        } catch {
-        }
-        safeError(error);
-        return cleanup(error);
-      } finally {
-        if (cleanedUp || isDone()) readerState.release();
-      }
-    },
-    cancel(reason) {
-      state = MergeState.Done;
-      return cleanup(reason);
-    }
+  stopAbortListener = listenForAbort(signal, (reason) => {
+    terminate("failure", reason);
   });
-  stopListeningToAbort = listenToAbort(opts?.signal, (reason) => {
-    safeError(reason);
-    cleanup(reason);
+  if (signal) serverSsr.hydrationScripts.requestSignal = signal;
+  serverSsr.onCleanup(() => {
+    if (!isTerminal()) terminate("failure", createCleanupAbortError());
   });
-  return stream;
+  return disarm;
 }
-function makeMainStream(serverSsr, appStream, opts) {
-  let stopListeningToInjectedHtml;
-  let stopListeningToSerializationFinished;
-  let serializationTimeoutHandle;
-  let lifetimeTimeoutHandle;
-  let stopListeningToAbort;
-  let cleanedUp = false;
-  let controller;
-  let closeWhenDrained = false;
-  let state = MergeState.ReadingBody;
-  const readerState = createReaderState(appStream);
-  const notifyAbort = createAbortNotifier(opts);
-  const pendingWrites = [];
-  let pendingWriteHead = 0;
-  let pendingWriteChars = 0;
-  function clearPending() {
-    pendingWrites.length = 0;
-    pendingWriteHead = 0;
-    pendingWriteChars = 0;
-  }
-  let drainResolve = null;
-  const waitForDrain = () => new Promise((r) => {
-    drainResolve = r;
-  });
-  const signalDrain = () => {
-    if (drainResolve) {
-      const r = drainResolve;
-      drainResolve = null;
-      r();
-    }
+function cleanupFailedStreamCreation(serverSsr, onAbort, error) {
+  try {
+    onAbort?.(error);
+  } catch {
+  }
+  serverSsr.cleanup();
+}
+function encodeStringSource(value, offset) {
+  const remaining = value.length - offset;
+  const capacity = Math.min(MAX_APPLICATION_STRING_CHUNK_BYTES, Math.max(MIN_APPLICATION_STRING_CHUNK_BYTES, Math.min(value.length, remaining * 3)));
+  const output = new Uint8Array(capacity);
+  const { read, written } = encodeIntoBoundedChunk(value, offset, output);
+  return {
+    bytes: written === output.length ? output : output.subarray(0, written),
+    read
   };
-  const isDone = () => state === MergeState.Done;
-  function drainPending() {
-    if (!controller || isDone()) return;
-    while (pendingWriteHead < pendingWrites.length) {
-      const ds = controller.desiredSize;
-      if (ds !== null && ds <= 0) return;
-      const next = pendingWrites[pendingWriteHead];
-      pendingWrites[pendingWriteHead] = "";
-      pendingWriteHead++;
-      pendingWriteChars -= next.length;
-      try {
-        controller.enqueue(textEncoder.encode(next));
-      } catch (error) {
-        safeError(error);
-        cleanup(error);
-        return;
-      }
-    }
-    if (pendingWriteHead >= pendingWrites.length) {
-      pendingWrites.length = 0;
-      pendingWriteHead = 0;
-    }
-    if (closeWhenDrained && pendingWriteHead >= pendingWrites.length) {
-      closeWhenDrained = false;
-      safeClose();
-      cleanup(void 0, false);
-    }
+}
+function transformReadableStreamWithRouter(router, appStream, opts) {
+  const serverSsr = router.serverSsr;
+  if (!serverSsr) throw new Error("Invariant failed: router.serverSsr is required");
+  const hydrationScripts = serverSsr.hydrationScripts;
+  let reader;
+  try {
+    reader = appStream.getReader();
+  } catch (error) {
+    cleanupFailedStreamCreation(serverSsr, opts?.onAbort, error);
+    throw error;
   }
-  function writeChunk(chunk) {
-    if (cleanedUp || isDone()) return;
-    if (!chunk.length) return;
-    if (pendingWriteChars + chunk.length > MAX_PENDING_WRITE_CHARS) {
-      const err = /* @__PURE__ */ new Error("SSR stream pending output exceeded maximum buffer");
-      safeError(err);
-      cleanup(err);
-      return;
-    }
-    pendingWrites.push(chunk);
-    pendingWriteChars += chunk.length;
-    drainPending();
+  try {
+    opts?.signal?.throwIfAborted();
+    if (hydrationScripts.reserveFastPath()) return makeMergeStream(serverSsr, reader, void 0, opts);
+    const hydrationOutput = hydrationScripts.claimOutput();
+    if (hydrationOutput.state === HydrationScriptOutputState.Failed) throw hydrationOutput.error;
+    return makeMergeStream(serverSsr, reader, hydrationOutput, opts);
+  } catch (error) {
+    cancelReader(reader, error);
+    cleanupFailedStreamCreation(serverSsr, opts?.onAbort, error);
+    throw error;
   }
-  function safeClose() {
-    if (isDone()) return;
-    state = MergeState.Done;
-    try {
-      controller?.close();
-    } catch {
-    }
+}
+function makeMergeStream(serverSsr, reader, hydrationOutput, opts) {
+  const hydrationScripts = serverSsr.hydrationScripts;
+  let controller;
+  let terminal = false;
+  let appDone = false;
+  let applicationPhase = hydrationOutput ? ApplicationPhase.BeforeBoundary : ApplicationPhase.PassThrough;
+  let insertionBoundary = false;
+  let stopHydrationOutputListener;
+  let appReadPending = false;
+  let settledAppRead;
+  let appBytes;
+  let appOffset = 0;
+  let documentCloseIndex;
+  let appString;
+  let appStringOffset = 0;
+  const useScriptCloseSafePoints = opts?.rendererSafePoint === "script-close";
+  const useRecordEndSafePoints = opts?.rendererSafePoint === "record-end";
+  let barrierMatcher;
+  let safePointMatcher;
+  let closeCarry;
+  let wakeResolve;
+  let disarmLifecycle = () => {
+  };
+  function waitForWake() {
+    return new Promise((resolve) => {
+      wakeResolve = resolve;
+    });
   }
-  function safeError(error) {
-    if (isDone()) return;
-    state = MergeState.Done;
-    try {
-      controller?.error(error);
-    } catch {
-    }
+  function wakePump() {
+    const resolve = wakeResolve;
+    wakeResolve = void 0;
+    resolve?.();
   }
-  function cleanup(reason, cancelReader = true) {
-    if (cleanedUp) return resolvedPromise;
-    cleanedUp = true;
-    try {
-      stopListeningToInjectedHtml?.();
-      stopListeningToSerializationFinished?.();
-    } catch {
+  function enqueueAppBytes(value) {
+    if (value.length === 0) return false;
+    controller.enqueue(value);
+    return true;
+  }
+  function finishAppChunk() {
+    appBytes = void 0;
+    documentCloseIndex = void 0;
+    if (appString === void 0 && useRecordEndSafePoints && closeCarry === void 0) insertionBoundary = true;
+  }
+  function emitAppRange(end, safePoint, finishCurrentChunk = end === appBytes.length) {
+    const value = appBytes;
+    const output = appOffset === 0 && end === value.length ? value : value.subarray(appOffset, end);
+    appOffset = end;
+    if (safePoint) insertionBoundary = true;
+    if (finishCurrentChunk) finishAppChunk();
+    return enqueueAppBytes(output);
+  }
+  function loadNextAppStringChunk() {
+    const value = appString;
+    const encoded = encodeStringSource(value, appStringOffset);
+    appStringOffset += encoded.read;
+    appBytes = encoded.bytes;
+    appOffset = 0;
+    if (appStringOffset === value.length) appString = void 0;
+  }
+  function processUntilBarrier() {
+    const value = appBytes;
+    if (!hydrationScripts.isInitialTaken()) return emitAppRange(value.length, false);
+    const matchEnd = advanceByteMatcher(barrierMatcher ??= {
+      pattern: HYDRATION_SCRIPT_BOUNDARY_BYTES,
+      anchorIndex: HYDRATION_SCRIPT_BOUNDARY_ANCHOR_INDEX,
+      matched: 0
+    }, value, appOffset);
+    if (matchEnd === void 0) return emitAppRange(value.length, false);
+    applicationPhase = ApplicationPhase.Merge;
+    hydrationScripts.liftBarrier();
+    return emitAppRange(matchEnd, true);
+  }
+  function enterHeldClose(consumed, prefix) {
+    appOffset = consumed;
+    applicationPhase = ApplicationPhase.HeldClose;
+    if (safePointMatcher) safePointMatcher.matched = 0;
+    insertionBoundary = true;
+    if (appOffset === appBytes.length) finishAppChunk();
+    return prefix ? enqueueAppBytes(prefix) : false;
+  }
+  function holdDocumentClose(matchStart) {
+    const value = appBytes;
+    return enterHeldClose(matchStart + DOCUMENT_CLOSE_BYTES.length, matchStart === appOffset ? void 0 : value.subarray(appOffset, matchStart));
+  }
+  function processUntilSafePoint(endIndex) {
+    const matchEnd = findSafePointEnd(appBytes, appOffset, endIndex);
+    if (matchEnd === void 0) return false;
+    return emitAppRange(matchEnd, true);
+  }
+  function findSafePointEnd(value, startIndex, endIndex) {
+    const hydrationState = hydrationOutput.state;
+    if (endIndex === startIndex || hydrationState === HydrationScriptOutputState.Done) return;
+    const scanValue = endIndex === value.length ? value : value.subarray(0, endIndex);
+    const matcher = safePointMatcher ??= {
+      pattern: SCRIPT_CLOSE_BYTES,
+      anchorIndex: SCRIPT_CLOSE_ANCHOR_INDEX,
+      matched: 0
+    };
+    const waiting = hydrationState === HydrationScriptOutputState.Waiting;
+    const matchEnd = advanceByteMatcher(matcher, scanValue, startIndex, waiting);
+    if (matchEnd === void 0) return;
+    if (waiting) matcher.matched = 0;
+    return matchEnd;
+  }
+  function processCloseCarry() {
+    const value = appBytes;
+    const carry = closeCarry;
+    const headLength = Math.min(value.length - appOffset, DOCUMENT_CLOSE_BYTES.length);
+    const combined = new Uint8Array(carry.length + headLength);
+    combined.set(carry);
+    combined.set(value.subarray(appOffset, appOffset + headLength), carry.length);
+    const matchStart = findExactBytes(combined, DOCUMENT_CLOSE_BYTES, 0, DOCUMENT_CLOSE_ANCHOR_INDEX);
+    const partial = matchStart < 0 ? getExactBytesPrefixAtEnd(combined, DOCUMENT_CLOSE_BYTES) : void 0;
+    const safeEnd = matchStart >= 0 ? matchStart : partial ?? combined.length;
+    if (useScriptCloseSafePoints) {
+      const safePointEnd = findSafePointEnd(combined, 0, safeEnd);
+      if (safePointEnd !== void 0) {
+        appOffset += safePointEnd - carry.length;
+        closeCarry = void 0;
+        insertionBoundary = true;
+        if (appOffset === value.length) finishAppChunk();
+        return enqueueAppBytes(combined.subarray(0, safePointEnd));
+      }
     }
-    stopListeningToInjectedHtml = void 0;
-    stopListeningToSerializationFinished = void 0;
-    stopListeningToAbort?.();
-    stopListeningToAbort = void 0;
-    if (serializationTimeoutHandle !== void 0) {
-      clearTimeout(serializationTimeoutHandle);
-      serializationTimeoutHandle = void 0;
+    if (matchStart >= 0) {
+      closeCarry = void 0;
+      return enterHeldClose(appOffset + matchStart + DOCUMENT_CLOSE_BYTES.length - carry.length, matchStart === 0 ? void 0 : combined.subarray(0, matchStart));
     }
-    if (lifetimeTimeoutHandle !== void 0) {
-      clearTimeout(lifetimeTimeoutHandle);
-      lifetimeTimeoutHandle = void 0;
+    closeCarry = partial === void 0 ? void 0 : combined.slice(partial);
+    appOffset += headLength;
+    return enqueueAppBytes(safeEnd === combined.length ? combined : combined.subarray(0, safeEnd));
+  }
+  function processUntilDocumentClose() {
+    const value = appBytes;
+    if (closeCarry) {
+      if (processCloseCarry()) return true;
+      if (applicationPhase === ApplicationPhase.HeldClose) return false;
+      if (appOffset >= value.length) {
+        finishAppChunk();
+        return false;
+      }
     }
-    clearPendingRouterHtml();
-    leftover = "";
-    pendingTail = "";
-    clearPending();
-    if (cancelReader) notifyAbort(reason);
-    const readerDone = cancelReader ? readerState.cancel(reason) : (readerState.release(), resolvedPromise);
-    signalDrain();
-    try {
-      serverSsr.cleanup();
-    } catch (error) {
-      console.error("Error in SSR cleanup:", error);
+    const matchStart = documentCloseIndex ??= findExactBytes(value, DOCUMENT_CLOSE_BYTES, appOffset, DOCUMENT_CLOSE_ANCHOR_INDEX);
+    if (matchStart >= 0) {
+      if (useScriptCloseSafePoints && processUntilSafePoint(matchStart)) return true;
+      return holdDocumentClose(matchStart);
     }
-    return readerDone;
-  }
-  const textDecoder = new TextDecoder();
-  const pendingRouterHtml = [];
-  let pendingRouterHtmlChars = 0;
-  let leftover = "";
-  let pendingTail = "";
-  let streamBarrierLifted = false;
-  let streamBarrierMarkerSeen = false;
-  let serializationFinished = false;
-  function noteBarrierMarker(chunk) {
-    if (streamBarrierMarkerSeen) return;
-    if (chunk.includes("$tsr-stream-barrier")) streamBarrierMarkerSeen = true;
-  }
-  function liftBarrierAfterBoundary() {
-    if (streamBarrierLifted) return;
-    if (!streamBarrierMarkerSeen) return;
-    streamBarrierLifted = true;
-    serverSsr.liftScriptBarrier();
-  }
-  const stream = new ReadableStream2({
-    start(c) {
-      controller = c;
-      drainPending();
-    },
-    pull() {
-      drainPending();
-      signalDrain();
-    },
-    cancel(reason) {
-      state = MergeState.Done;
-      return cleanup(reason);
+    const partial = getExactBytesPrefixAtEnd(value, DOCUMENT_CLOSE_BYTES, appOffset);
+    const safeEnd = partial ?? value.length;
+    if (useScriptCloseSafePoints && processUntilSafePoint(safeEnd)) return true;
+    closeCarry = partial === void 0 ? void 0 : value.slice(partial);
+    return emitAppRange(safeEnd, false, true);
+  }
+  function processAppChunk() {
+    if (appOffset >= appBytes.length) {
+      finishAppChunk();
+      return false;
     }
-  });
-  function drainRouterHtml() {
-    if (cleanedUp || isDone()) return;
-    let html;
-    try {
-      html = serverSsr.takeBufferedHtml();
-    } catch (error) {
-      safeError(error);
-      cleanup(error);
+    insertionBoundary = false;
+    if (applicationPhase === ApplicationPhase.BeforeBoundary) return processUntilBarrier();
+    if (applicationPhase === ApplicationPhase.Merge) return processUntilDocumentClose();
+    const value = appBytes;
+    if (useScriptCloseSafePoints && processUntilSafePoint(value.length)) return true;
+    return emitAppRange(value.length, false);
+  }
+  function terminate(kind, reason) {
+    if (terminal) return;
+    terminal = true;
+    stopHydrationOutputListener?.();
+    stopHydrationOutputListener = void 0;
+    disarmLifecycle();
+    settledAppRead = void 0;
+    appBytes = void 0;
+    documentCloseIndex = void 0;
+    appString = void 0;
+    closeCarry = void 0;
+    wakePump();
+    return finalizeSsrStream(kind, reason, controller, reader, serverSsr, opts?.onAbort);
+  }
+  function startAppRead() {
+    if (appReadPending || settledAppRead || terminal) return;
+    appReadPending = true;
+    reader.read().then((result) => {
+      appReadPending = false;
+      if (!terminal) {
+        if (result.done) acceptAppRead(result);
+        else settledAppRead = result;
+        wakePump();
+      }
+    }, (error) => {
+      appReadPending = false;
+      if (!terminal) handlePumpError(error);
+    });
+  }
+  function acceptAppRead(result) {
+    if (result.done) {
+      appDone = true;
+      insertionBoundary = closeCarry === void 0;
+      hydrationScripts.startSerializationTimeout(opts?.timeoutMs ?? DEFAULT_SERIALIZATION_TIMEOUT_MS);
+      serverSsr.setRenderFinished();
       return;
     }
-    if (!html) return;
-    if (state >= MergeState.Draining) {
-      const err = /* @__PURE__ */ new Error("SSR router HTML injected after stream finalization");
-      safeError(err);
-      cleanup(err);
+    const value = result.value;
+    if (typeof value === "string") {
+      if (value.length === 0) return;
+      appString = value;
+      appStringOffset = 0;
+      insertionBoundary = false;
+      loadNextAppStringChunk();
       return;
     }
-    if (state === MergeState.HoldingTail) {
-      flushPendingRouterHtml();
-      writeChunk(html);
-    } else {
-      if (pendingRouterHtmlChars + html.length > MAX_ROUTER_HTML_CHARS) {
-        const err = /* @__PURE__ */ new Error("SSR router HTML exceeded maximum buffer");
-        safeError(err);
-        cleanup(err);
-        return;
-      }
-      pendingRouterHtml.push(html);
-      pendingRouterHtmlChars += html.length;
-    }
-  }
-  function flushPendingRouterHtml() {
-    if (!pendingRouterHtml.length) return;
-    for (const html of pendingRouterHtml) writeChunk(html);
-    clearPendingRouterHtml();
-  }
-  function clearPendingRouterHtml() {
-    pendingRouterHtml.length = 0;
-    pendingRouterHtmlChars = 0;
-  }
-  function appendTail(chunk) {
-    pendingTail += chunk;
-    if (pendingTail.length > MAX_TAIL_CHARS) throw new Error("SSR stream tail exceeded maximum buffer");
-  }
-  function waitForBackpressure() {
-    return !!(controller && controller.desiredSize !== null && controller.desiredSize <= 0);
-  }
-  function startSerializationTimeout() {
-    if (cleanedUp || isDone()) return;
-    if (serializationTimeoutHandle !== void 0) return;
-    const timeoutMs2 = opts?.timeoutMs ?? DEFAULT_SERIALIZATION_TIMEOUT_MS;
-    serializationTimeoutHandle = setTimeout(() => {
-      if (!cleanedUp && !isDone()) {
-        const err = /* @__PURE__ */ new Error("Serialization timeout after app render finished");
-        console.error("Serialization timeout after app render finished");
-        safeError(err);
-        cleanup(err);
-      }
-    }, timeoutMs2);
-  }
-  function tryFinish() {
-    if (state !== MergeState.AppDone || !serializationFinished) return;
-    if (cleanedUp || isDone()) return;
-    if (serializationTimeoutHandle !== void 0) {
-      clearTimeout(serializationTimeoutHandle);
-      serializationTimeoutHandle = void 0;
+    if (value.byteLength === 0) return;
+    appBytes = value;
+    appOffset = 0;
+    insertionBoundary = false;
+  }
+  async function loadNextAppChunk() {
+    if (appString !== void 0) {
+      loadNextAppStringChunk();
+      return;
     }
-    drainRouterHtml();
-    if (cleanedUp || isDone()) return;
-    const decoderRemainder = textDecoder.decode();
-    if (leftover) writeChunk(leftover);
-    if (cleanedUp || isDone()) return;
-    if (decoderRemainder) writeChunk(decoderRemainder);
-    if (cleanedUp || isDone()) return;
-    flushPendingRouterHtml();
-    if (cleanedUp || isDone()) return;
-    if (pendingTail) writeChunk(pendingTail);
-    if (cleanedUp || isDone()) return;
-    leftover = "";
-    pendingTail = "";
-    state = MergeState.Draining;
-    closeWhenDrained = true;
-    drainPending();
-  }
-  function finishAppRendering() {
-    if (state >= MergeState.AppDone) return;
-    state = MergeState.AppDone;
-    try {
-      serverSsr.setRenderFinished();
-    } catch (error) {
-      safeError(error);
-      cleanup(error);
+    if (settledAppRead) {
+      const settled = settledAppRead;
+      settledAppRead = void 0;
+      acceptAppRead(settled);
       return;
     }
-    drainRouterHtml();
-    if (cleanedUp || isDone()) return;
-    serializationFinished = serializationFinished || serverSsr.isSerializationFinished();
-    if (serializationFinished) tryFinish();
-    else startSerializationTimeout();
-  }
-  const timeoutMs = opts?.timeoutMs ?? DEFAULT_SERIALIZATION_TIMEOUT_MS;
-  const lifetimeMs = opts?.lifetimeMs ?? timeoutMs * 2;
-  lifetimeTimeoutHandle = setTimeout(() => {
-    if (!cleanedUp && !isDone()) {
-      const err = /* @__PURE__ */ new Error("Stream lifetime exceeded");
-      console.warn(`SSR stream transform exceeded maximum lifetime (${lifetimeMs}ms), forcing cleanup`);
-      safeError(err);
-      cleanup(err);
+    if (!(applicationPhase !== ApplicationPhase.BeforeBoundary && insertionBoundary && hydrationOutput.state !== HydrationScriptOutputState.Done) && !appReadPending) {
+      const result = await reader.read();
+      if (terminal) return;
+      acceptAppRead(result);
+      return;
     }
-  }, lifetimeMs);
-  stopListeningToInjectedHtml = serverSsr.onInjectedHtml(() => {
-    drainRouterHtml();
-  });
-  stopListeningToSerializationFinished = serverSsr.onSerializationFinished(() => {
-    serializationFinished = true;
-    drainRouterHtml();
-    tryFinish();
-  });
-  drainRouterHtml();
-  if (cleanedUp || isDone()) return stream;
-  serializationFinished = serializationFinished || serverSsr.isSerializationFinished();
-  if (serializationFinished) {
-    drainRouterHtml();
-    if (cleanedUp || isDone()) return stream;
-  }
-  stopListeningToAbort = listenToAbort(opts?.signal, (reason) => {
-    safeError(reason);
-    cleanup(reason);
-  });
-  if (cleanedUp || isDone()) return stream;
-  (async () => {
+    const wake = waitForWake();
+    startAppRead();
+    await wake;
+  }
+  async function pumpPassThrough() {
     try {
-      while (true) {
-        if (waitForBackpressure()) {
-          await waitForDrain();
-          if (cleanedUp || isDone()) return;
+      for (; ; ) {
+        if (appBytes) {
+          const remainder = appOffset === 0 ? appBytes : appBytes.subarray(appOffset);
+          appBytes = void 0;
+          if (enqueueAppBytes(remainder)) return;
+          continue;
         }
-        const { done, value } = await readerState.reader.read();
-        if (done) break;
-        if (cleanedUp || isDone()) return;
-        const text = typeof value === "string" ? value : textDecoder.decode(value, { stream: true });
-        const chunkString = leftover ? leftover + text : text;
-        if (state >= MergeState.HoldingTail) {
-          appendTail(chunkString);
-          leftover = "";
+        if (appString !== void 0) {
+          loadNextAppStringChunk();
           continue;
         }
-        const boundary = findHtmlBoundary(chunkString);
-        if (boundary < -1) {
-          const bodyEndIndex = -boundary - 2;
-          state = MergeState.HoldingTail;
-          appendTail(chunkString.slice(bodyEndIndex));
-          const bodyChunk = chunkString.slice(0, bodyEndIndex);
-          writeChunk(bodyChunk);
-          if (cleanedUp || isDone()) return;
-          noteBarrierMarker(bodyChunk);
-          liftBarrierAfterBoundary();
-          if (cleanedUp || isDone()) return;
-          flushPendingRouterHtml();
-          leftover = "";
+        if (appDone) {
+          terminate("complete");
+          return;
+        }
+        if (appReadPending) {
+          await waitForWake();
           continue;
         }
-        const lastClosingTagEnd = boundary;
-        if (lastClosingTagEnd > 0) {
-          const safeChunk = chunkString.slice(0, lastClosingTagEnd);
-          writeChunk(safeChunk);
-          if (cleanedUp || isDone()) return;
-          noteBarrierMarker(safeChunk);
-          liftBarrierAfterBoundary();
-          if (cleanedUp || isDone()) return;
-          flushPendingRouterHtml();
-          leftover = chunkString.slice(lastClosingTagEnd);
-          if (leftover.length > MAX_LEFTOVER_CHARS) {
-            noteBarrierMarker(leftover);
-            writeChunk(leftover.slice(0, leftover.length - MAX_LEFTOVER_CHARS));
-            leftover = leftover.slice(-2048);
-          }
-        } else {
-          const combined = chunkString;
-          if (combined.length > MAX_LEFTOVER_CHARS) {
-            noteBarrierMarker(combined);
-            const flushUpto = combined.length - MAX_LEFTOVER_CHARS;
-            writeChunk(combined.slice(0, flushUpto));
-            leftover = combined.slice(flushUpto);
-          } else leftover = combined;
+        let result = settledAppRead;
+        if (result) settledAppRead = void 0;
+        else {
+          result = await reader.read();
+          if (terminal) return;
+        }
+        if (result.done || typeof result.value === "string") {
+          acceptAppRead(result);
+          continue;
+        }
+        if (result.value.byteLength > 0) {
+          controller.enqueue(result.value);
+          return;
         }
       }
-      if (cleanedUp || isDone()) return;
-      finishAppRendering();
     } catch (error) {
-      if (cleanedUp) return;
-      console.error("Error reading appStream:", error);
-      if (state < MergeState.AppDone) try {
-        serverSsr.setRenderFinished();
-      } catch {
+      handlePumpError(error);
+    }
+  }
+  async function pump() {
+    const output = hydrationOutput;
+    while (!terminal) {
+      const hydrationState = output.state;
+      if (hydrationState === HydrationScriptOutputState.Active) {
+        controller.enqueue(output.pullChunk());
+        return;
       }
-      safeError(error);
-      cleanup(error);
-    } finally {
-      readerState.release();
+      if (applicationPhase !== ApplicationPhase.BeforeBoundary && insertionBoundary && hydrationState === HydrationScriptOutputState.Ready) {
+        if (!appDone && !appBytes && appString === void 0) startAppRead();
+        controller.enqueue(output.pullChunk());
+        return;
+      }
+      if (applicationPhase === ApplicationPhase.Merge && hydrationState === HydrationScriptOutputState.Done && closeCarry === void 0 && hydrationScripts.reserveFastPath(output)) {
+        applicationPhase = ApplicationPhase.PassThrough;
+        stopHydrationOutputListener?.();
+        stopHydrationOutputListener = void 0;
+        return pumpPassThrough();
+      }
+      if (appBytes) {
+        if (processAppChunk()) return;
+        continue;
+      }
+      if (appDone) {
+        if (applicationPhase === ApplicationPhase.BeforeBoundary) {
+          hydrationScripts.skipInitialTake();
+          applicationPhase = ApplicationPhase.Merge;
+          insertionBoundary = true;
+          continue;
+        }
+        if (closeCarry) {
+          const carry = closeCarry;
+          closeCarry = void 0;
+          insertionBoundary = true;
+          if (enqueueAppBytes(carry)) return;
+          continue;
+        }
+        if (hydrationState === HydrationScriptOutputState.Waiting) {
+          await waitForWake();
+          continue;
+        }
+        if (applicationPhase === ApplicationPhase.HeldClose) {
+          controller.enqueue(DOCUMENT_CLOSE_BYTES.slice());
+          terminate("complete");
+          return;
+        }
+        terminate("complete");
+        return;
+      }
+      await loadNextAppChunk();
+    }
+  }
+  function handlePumpError(error) {
+    if (terminal) return;
+    console.error("Error processing appStream:", error);
+    terminate("failure", error);
+  }
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    },
+    pull() {
+      return applicationPhase === ApplicationPhase.PassThrough ? pumpPassThrough() : pump().catch(handlePumpError);
+    },
+    cancel(reason) {
+      return terminate("cancel", reason);
+    }
+  });
+  if (hydrationOutput) stopHydrationOutputListener = hydrationOutput.subscribe(() => {
+    if (hydrationOutput.state === HydrationScriptOutputState.Failed) {
+      terminate("failure", hydrationOutput.error);
+      return;
     }
-  })().catch((error) => {
-    if (cleanedUp) return;
-    console.error("Error in stream transform:", error);
-    safeError(error);
-    cleanup(error);
+    wakePump();
   });
+  disarmLifecycle = armStreamLifecycle(serverSsr, opts, () => terminal, terminate);
   return stream;
 }
 
-// node_modules/.pnpm/@tanstack+react-router@1.170.32_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@tanstack/react-router/dist/esm/ssr/renderRouterToStream.js
+// node_modules/.pnpm/@tanstack+react-router@1.170.40_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@tanstack/react-router/dist/esm/ssr/renderRouterToStream.js
 import ReactDOMServer from "react-dom/server";
-import { PassThrough } from "node:stream";
+import { PassThrough, Readable } from "node:stream";
 
 // node_modules/.pnpm/isbot@5.2.1/node_modules/isbot/index.mjs
 var fullPattern = " daum[ /]| deusu/|(?:^|[^g])news(?!sapphire)|(?<! channel/|google/)google(?!(?:wv|app|/google| pixel))|(?<! cu)bots?(?:\\b|_)|(?<!cam)scan|(?<!lib)http|24x7|;\\s\\w+;$|@[a-z][\\w-]+\\.|\\(\\)|\\.com\\b|\\b\\w+\\.ai|\\bbw/|\\bdlc\\b|\\bort/|\\bperl\\b|\\btime/|\\||^[<\\(;]|^[\\w \\.\\-\\(?:\\):%]+(?:/v?\\d+(?:\\.\\d+)?(?:\\.\\d{1,10})*?)?(?:,|$)|^[\\w\\-]+/[\\w]+$|^[^ ]{50,}$|^\\d+\\b|^\\w*search\\b|^\\w+/[\\w\\(\\)]*$|^\\w+/\\d\\.\\d\\s\\([\\w@]+\\)$|^active|^ad muncher|^amaya|^apache/|^avsdevicesdk/|^azure|^biglotron|^blackbox exporter|^bot|^clamav[ /]|^claude-code/|^client/|^cobweb/|^custom|^ddg[_-]android|^discourse|^dispatch/\\d|^downcast/|^duckduckgo|^email|^exodusmovement|^facebook|^getright/|^gozilla/|^hobbit|^hotzonu|^hwcdn/|^igetter/|^jeode/|^jetty/|^jigsaw|^microsoft bits|^movabletype|^mozilla/\\d\\.\\d\\s[\\w\\.-]+$|^mozilla/\\d\\.\\d\\s\\((?:compatible;)?(?:\\s?[\\w\\d-.]+\\/\\d+\\.\\d+)?\\)$|^navermailapp|^netsurf|^offline|^openai/|^owler|^php|^postman|^ps_daily/|^python|^rank|^read|^reed|^remove\\.bg/|^rest|^rss|^snapchat|^sora |^space bison|^stape/|^svn|^swcd |^taringa|^thumbor/|^track|^w3c|^webbandit/|^webcopier|^wget|^whatsapp|^wordpress|^xenu link sleuth|^yahoo|^yandex|^zdm/\\d|^zoom marketplace/|abuse|advisor|agent\\b|analyzer|archive|ask jeeves/teoma|attracta|audit|bluecoat drtr|browsex|burpcollaborator|capture|catch|check\\b|checker|chrome-lighthouse|chromeframe|classifier|cloudflare|collapsify\\b|convertify|cookiehubverify/|crawl|cursor/|cypress/|dareboost|datanyze|dejaclick|detect|discovery|dmbrowser|download|exaleadcloudview|feed|fetcher|firephp|foregenix|functionize|grab|hardenize\\b|headless|hotjar|httrack|hubspot marketing grader|ibisbrowser|infrawatch|insight|inspect|iplabel|java(?!;)|library|linkcheck|linktiger|mail\\.ru/|manager|manus-user/|marketgoo/|measure|monitor\\b|neustar wpm|node\\b|nutch|offbyone|openvas|optimize|pageburst|pagespeed|parser|phantomjs|pingdom|playwright|powermarks|preview|productfinder|prospectingstudio|proxy|ptst[ /]\\d|radar|readable/|retriever|rexx;|rigor|rss\\b|scrape|securityheaders|selenium|server|silktide|sindup/|sogou|sparkler/|speedcurve|spider|splash|statuscake|supercleaner|synapse|synthetic|testlocally|tools|torrent|transcoder|upday/|url|validator|virtuoso|wappalyzer|watchtowr|webglance|webkit2png|whatcms/|xtate/";
@@ -1320,113 +1850,87 @@ function isBot(userAgent) {
 }
 var isbot = isBot;
 
-// node_modules/.pnpm/@tanstack+react-router@1.170.32_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@tanstack/react-router/dist/esm/ssr/renderRouterToStream.js
-var noop2 = () => {
-};
-async function waitForReadyOrAbort(ready, signal) {
-  let cleanup = noop2;
-  try {
-    await Promise.race([ready, new Promise((resolve) => {
-      const onAbort = () => resolve();
-      cleanup = () => signal.removeEventListener("abort", onAbort);
-      signal.addEventListener("abort", onAbort, { once: true });
-      if (signal.aborted) resolve();
-    })]);
-  } finally {
-    cleanup();
-  }
-}
-var isAbortError = (request, error) => request.signal.aborted && error === request.signal.reason || error instanceof Error && error.name === "AbortError";
+// node_modules/.pnpm/@tanstack+react-router@1.170.40_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@tanstack/react-router/dist/esm/ssr/renderRouterToStream.js
 var renderRouterToStream = async ({ request, router, responseHeaders, children }) => {
-  if (typeof ReactDOMServer.renderToReadableStream === "function") {
-    const stream = await ReactDOMServer.renderToReadableStream(children, {
-      signal: request.signal,
-      nonce: router.options.ssr?.nonce,
-      progressiveChunkSize: Number.POSITIVE_INFINITY,
-      onError: (error, info) => {
-        if (!isAbortError(request, error)) console.error("Error in renderToReadableStream:", error, info);
-      }
-    });
-    if (isbot(request.headers.get("User-Agent"))) await waitForReadyOrAbort(stream.allReady, request.signal);
-    const responseStream = transformReadableStreamWithRouter(router, stream, {
-      signal: request.signal,
-      onAbort: () => stream.cancel().catch(() => {
-      })
-    });
-    return createSsrStreamResponse(router, new Response(responseStream, {
-      status: router._serverResult?.type === "render" ? router._serverResult.status : 200,
-      headers: responseHeaders
-    }));
+  const signal = request.signal;
+  if (signal.aborted) {
+    router.serverSsr?.cleanup();
+    throw signal.reason;
   }
-  if (typeof ReactDOMServer.renderToPipeableStream === "function") {
-    const reactAppPassthrough = new PassThrough();
-    let pipeable;
-    let responseAttached = false;
-    let aborted = false;
-    let endedBeforeAttach = false;
-    let pendingAbortReason;
-    const toError = (reason) => reason instanceof Error ? reason : new Error(String(reason ?? "SSR aborted"));
-    const destroyError = (reason) => reason === void 0 ? void 0 : toError(reason);
-    const pendingDestroyError = () => pendingAbortReason === void 0 ? toError(pendingAbortReason) : destroyError(pendingAbortReason);
-    const finishPassThrough = (reason, opts) => {
-      if (reactAppPassthrough.destroyed) return;
-      if (responseAttached) reactAppPassthrough.destroy(opts?.defaultError ? toError(reason) : destroyError(reason));
-      else endedBeforeAttach = true;
-    };
-    const abortPipeable = (reason, opts) => {
-      if (aborted) return;
-      aborted = true;
-      pendingAbortReason = reason;
-      const err = toError(reason);
-      try {
-        pipeable?.abort(err);
-      } catch {
-      }
-      finishPassThrough(reason, opts);
-    };
-    if (request.signal.aborted) abortPipeable(request.signal.reason);
-    else {
-      const onRequestAbort = () => abortPipeable(request.signal.reason);
-      request.signal.addEventListener("abort", onRequestAbort, { once: true });
-      router.serverSsr?.onCleanup(() => {
-        request.signal.removeEventListener("abort", onRequestAbort);
-      });
-    }
-    try {
-      pipeable = ReactDOMServer.renderToPipeableStream(children, {
+  let rendererTeardown = false;
+  const bot = isbot(request.headers.get("User-Agent"));
+  const onError2 = (renderer) => (error, info) => {
+    if (!rendererTeardown && !signal.aborted) console.error(`Error in ${renderer}:`, error, info);
+  };
+  try {
+    if (typeof ReactDOMServer.renderToReadableStream === "function") {
+      const stream = await ReactDOMServer.renderToReadableStream(children, {
+        signal,
         nonce: router.options.ssr?.nonce,
         progressiveChunkSize: Number.POSITIVE_INFINITY,
-        ...isbot(request.headers.get("User-Agent")) ? { onAllReady() {
-          pipeable.pipe(reactAppPassthrough);
-        } } : { onShellReady() {
-          pipeable.pipe(reactAppPassthrough);
-        } },
-        onError: (error, info) => {
-          if (!isAbortError(request, error)) console.error("Error in renderToPipeableStream:", error, info);
-          abortPipeable(error, { defaultError: true });
+        onError: onError2("renderToReadableStream")
+      });
+      const rendererAbort = bot ? new AbortController() : void 0;
+      const responseStream = transformReadableStreamWithRouter(router, stream, {
+        rendererSafePoint: "script-close",
+        signal,
+        onAbort: (reason) => {
+          rendererTeardown = true;
+          rendererAbort?.abort(reason);
         }
       });
-    } catch (e) {
-      console.error("Error in renderToPipeableStream:", e);
-      router.serverSsr?.cleanup();
-      throw e;
+      if (rendererAbort) await waitForReason(stream.allReady, rendererAbort.signal);
+      return createSsrStreamResponse(router, new Response(responseStream, {
+        status: getSsrStatus(router),
+        headers: responseHeaders
+      }));
     }
-    const responseStream = transformPipeableStreamWithRouter(router, reactAppPassthrough, {
-      signal: request.signal,
-      onAbort: abortPipeable
-    });
-    responseAttached = true;
-    if (endedBeforeAttach) reactAppPassthrough.destroy(pendingDestroyError());
-    if (aborted && pipeable) try {
-      pipeable.abort(toError(pendingAbortReason));
-    } catch {
+    if (typeof ReactDOMServer.renderToPipeableStream === "function") {
+      const reactAppPassthrough = new PassThrough();
+      let pipeable;
+      let resolveReady;
+      const ready = new Promise((resolve) => {
+        resolveReady = resolve;
+      });
+      const rendererAbort = new AbortController();
+      const abortPipeable = (reason) => {
+        if (rendererTeardown) return;
+        rendererTeardown = true;
+        rendererAbort.abort(reason);
+        try {
+          pipeable?.abort(reason);
+        } catch {
+        }
+      };
+      try {
+        pipeable = ReactDOMServer.renderToPipeableStream(children, {
+          nonce: router.options.ssr?.nonce,
+          progressiveChunkSize: Number.POSITIVE_INFINITY,
+          ...bot ? { onAllReady: resolveReady } : { onShellReady: resolveReady },
+          onError: onError2("renderToPipeableStream"),
+          onShellError: (error) => rendererAbort.abort(error)
+        });
+        const responseStream = transformReadableStreamWithRouter(router, Readable.toWeb(reactAppPassthrough), {
+          rendererSafePoint: "script-close",
+          signal,
+          onAbort: abortPipeable
+        });
+        await waitForReason(ready, rendererAbort.signal);
+        pipeable.pipe(reactAppPassthrough);
+        return createSsrStreamResponse(router, new Response(responseStream, {
+          status: getSsrStatus(router),
+          headers: responseHeaders
+        }));
+      } catch (error) {
+        abortPipeable(error);
+        throw error;
+      }
     }
-    return createSsrStreamResponse(router, new Response(responseStream, {
-      status: router._serverResult?.type === "render" ? router._serverResult.status : 200,
-      headers: responseHeaders
-    }));
+    throw new Error("No renderToReadableStream or renderToPipeableStream found in react-dom/server. Ensure you are using a version of react-dom that supports streaming.");
+  } catch (error) {
+    router.serverSsr?.cleanup();
+    throw error;
   }
-  throw new Error("No renderToReadableStream or renderToPipeableStream found in react-dom/server. Ensure you are using a version of react-dom that supports streaming.");
 };
 
 // web/app/dist/server/server.js
@@ -2024,7 +2528,7 @@ function getResponse() {
 }
 var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
 async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("./_tanstack-start-manifest_v-vL58CVrY-7SDCWIHD.js");
+  const { tsrStartManifest } = await import("./_tanstack-start-manifest_v-CaT-3S-N-VAOGUHEJ.js");
   const startManifest = tsrStartManifest();
   let routes = startManifest.routes;
   routes[rootRouteId];
@@ -2044,50 +2548,23 @@ async function getStartManifest(matchedRoutes) {
   };
 }
 var manifest = {};
-async function getServerFnById(id, access) {
-  const serverFnInfo = manifest[id];
-  if (!serverFnInfo) throw new Error("Server function info not found for " + id);
-  const fnModule = serverFnInfo.module ?? await serverFnInfo.importer();
-  if (!fnModule) throw new Error("Server function module not resolved for " + id);
-  const action = fnModule[serverFnInfo.functionName];
-  if (!action) throw new Error("Server function module export not resolved for serverFn ID: " + id);
-  return action;
-}
-var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
-var TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
-var X_TSS_SERIALIZED = "x-tss-serialized";
-var X_TSS_RAW_RESPONSE = "x-tss-raw";
-var TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
-var FrameType = {
-  /** Seroval JSON chunk (NDJSON line) */
-  JSON: 0,
-  /** Raw stream data chunk */
-  CHUNK: 1,
-  /** Raw stream end (EOF) */
-  END: 2,
-  /** Raw stream error */
-  ERROR: 3
-};
-var TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
-function isSafeKey(key) {
-  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
-}
-function safeObjectMerge(target, source) {
-  const result = /* @__PURE__ */ Object.create(null);
-  if (target) {
-    for (const key of Object.keys(target)) if (isSafeKey(key)) result[key] = target[key];
-  }
-  if (source && typeof source === "object") {
-    for (const key of Object.keys(source)) if (isSafeKey(key)) result[key] = source[key];
-  }
-  return result;
-}
-function createNullProtoObject(source) {
-  if (!source) return /* @__PURE__ */ Object.create(null);
-  const obj = /* @__PURE__ */ Object.create(null);
-  for (const key of Object.keys(source)) if (isSafeKey(key)) obj[key] = source[key];
-  return obj;
+async function getServerFnById(id, access) {
+  const serverFnInfo = manifest[id];
+  if (!serverFnInfo) throw new Error("Server function info not found for " + id);
+  const fnModule = serverFnInfo.module ??= await serverFnInfo.importer();
+  if (!fnModule) throw new Error("Server function module not resolved for " + id);
+  const action = fnModule[serverFnInfo.functionName];
+  if (!action) throw new Error("Server function module export not resolved for serverFn ID: " + id);
+  return action;
 }
+var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
+var TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
+var X_TSS_SERIALIZED = "x-tss-serialized";
+var X_TSS_RAW_RESPONSE = "x-tss-raw";
+var TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
+var MAX_FRAME_PAYLOAD_SIZE = 16777216;
+var MAX_FRAMED_STREAMS = 1024;
+var TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
 var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:start-storage-context");
 var globalObj = globalThis;
 if (!globalObj[GLOBAL_STORAGE_KEY]) globalObj[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
@@ -2101,103 +2578,8 @@ function getStartContext(opts) {
   return context;
 }
 var getStartOptions = () => getStartContext().startOptions;
-function flattenMiddlewares(middlewares, maxDepth = 100) {
-  const seen = /* @__PURE__ */ new Set();
-  const flattened = [];
-  const recurse = (middleware, depth) => {
-    if (depth > maxDepth) throw new Error(`Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`);
-    middleware.forEach((m) => {
-      if (m.options.middleware) recurse(m.options.middleware, depth + 1);
-      if (!seen.has(m)) {
-        seen.add(m);
-        flattened.push(m);
-      }
-    });
-  };
-  recurse(middlewares, 0);
-  return flattened;
-}
-var createMiddleware = (options, __opts) => {
-  const resolvedOptions = {
-    type: "request",
-    ...__opts || options
-  };
-  const setValidator = (validator) => {
-    return createMiddleware({}, Object.assign(resolvedOptions, {
-      validator,
-      inputValidator: validator
-    }));
-  };
-  return {
-    options: resolvedOptions,
-    middleware: (middleware) => {
-      return createMiddleware({}, Object.assign(resolvedOptions, { middleware }));
-    },
-    validator: setValidator,
-    inputValidator: setValidator,
-    client: (client) => {
-      return createMiddleware({}, Object.assign(resolvedOptions, { client }));
-    },
-    server: (server) => {
-      return createMiddleware({}, Object.assign(resolvedOptions, { server }));
-    }
-  };
-};
-var innerCreateCsrfMiddleware = (opts = {}) => {
-  return createMiddleware().server(async (ctx) => {
-    const csrfCtx = ctx;
-    if (opts.filter && !await opts.filter(csrfCtx)) return ctx.next();
-    if (await isCsrfRequestAllowed(opts, csrfCtx)) return ctx.next();
-    return getFailureResponse(opts, csrfCtx);
-  });
-};
-var createCsrfMiddleware = innerCreateCsrfMiddleware;
-async function isCsrfRequestAllowed(opts, ctx) {
-  const result = await getCsrfRequestValidationResult(opts, ctx);
-  return result === true || result === void 0 && opts.allowRequestsWithoutOriginCheck === true;
-}
-async function getCsrfRequestValidationResult(opts, ctx) {
-  const fetchSite = ctx.request.headers.get("Sec-Fetch-Site");
-  if (fetchSite !== null) return matchValue(opts.secFetchSite ?? "same-origin", fetchSite, ctx);
-  const origin = ctx.request.headers.get("Origin");
-  if (origin !== null) {
-    if (opts.origin) return matchValue(opts.origin, origin, ctx);
-    return origin === new URL(ctx.request.url).origin;
-  }
-  const referer = ctx.request.headers.get("Referer");
-  if (referer === null || opts.referer === false) return;
-  if (typeof opts.referer === "function") return opts.referer(referer, ctx);
-  if (opts.origin) {
-    const refererOrigin = getOriginFromUrl(referer);
-    return refererOrigin !== void 0 && matchValue(opts.origin, refererOrigin, ctx);
-  }
-  return isRefererSameOrigin(referer, new URL(ctx.request.url).origin);
-}
-async function matchValue(matcher, value, ctx) {
-  if (typeof matcher === "function") return matcher(value, ctx);
-  if (Array.isArray(matcher)) return matcher.includes(value);
-  return value === matcher;
-}
-function getOriginFromUrl(url) {
-  try {
-    return new URL(url).origin;
-  } catch {
-    return;
-  }
-}
-function isRefererSameOrigin(referer, requestOrigin) {
-  if (referer === requestOrigin) return true;
-  if (!referer.startsWith(requestOrigin)) return false;
-  if (referer.length === requestOrigin.length) return true;
-  const code = referer.charCodeAt(requestOrigin.length);
-  return code === 47 || code === 63 || code === 35;
-}
-async function getFailureResponse(opts, ctx) {
-  if (typeof opts.failureResponse === "function") return opts.failureResponse(ctx);
-  return opts.failureResponse?.clone() ?? new Response("Forbidden", { status: 403 });
-}
-function getDefaultSerovalPlugins() {
-  return [...getStartOptions()?.serializationAdapters?.map(makeSerovalPlugin) ?? [], ...defaultSerovalPlugins];
+function getSerovalPlugins(routerPlugins) {
+  return [...getStartOptions()?.serializationAdapters?.map(makeSerovalPlugin) ?? [], ...routerPlugins];
 }
 var SYM_ASYNC_ITERATOR = Symbol.asyncIterator;
 var SYM_HAS_INSTANCE = Symbol.hasInstance;
@@ -2297,6 +2679,8 @@ var NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(4);
 var INFINITY_NODE = /* @__PURE__ */ createConstantNode(5);
 var NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(6);
 var NAN_NODE = /* @__PURE__ */ createConstantNode(7);
+var MIN_JSON_STRINGIFY_LENGTH = 64;
+var JSON_ESCAPE_DIFFERENCES = /[\x00-\x07\x0b\x0e-\x1f<\u2028\u2029\ud800-\udfff]/;
 function serializeChar(str) {
   switch (str) {
     case '"':
@@ -2324,6 +2708,7 @@ function serializeChar(str) {
   }
 }
 function serializeString(str) {
+  if (str.length >= MIN_JSON_STRINGIFY_LENGTH && !JSON_ESCAPE_DIFFERENCES.test(str)) return JSON.stringify(str).slice(1, -1);
   let result = "";
   let lastPos = 0;
   let replacement;
@@ -2365,6 +2750,7 @@ function deserializeReplacer(str) {
   }
 }
 function deserializeString(str) {
+  if (typeof str === "string" && !str.includes("\\")) return str;
   return str.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, deserializeReplacer);
 }
 var { toString: objectToString } = Object.prototype;
@@ -2638,7 +3024,10 @@ var STREAM_CONSTRUCTOR = () => {
   let count = 0;
   const internal = {
     flush(value, mode, x) {
-      for (x = 0; x < count; x++) if (listeners[x]) listeners[x][mode](value);
+      for (x = 0; x < count; x++) {
+        const listener = listeners[x];
+        if (listener) listener[mode](value);
+      }
     },
     up(listener, x, z, current) {
       for (x = 0, z = buffer.length; x < z; x++) {
@@ -2647,16 +3036,20 @@ var STREAM_CONSTRUCTOR = () => {
         else listener.next(current);
       }
     },
-    on(listener, temp) {
+    on(listener, temp = 0) {
+      let subscribed = alive;
       if (alive) {
-        temp = count++;
+        for (temp = 0; temp < count; temp++) if (!listeners[temp]) break;
+        if (temp === count) count++;
         listeners[temp] = listener;
       }
       internal.up(listener);
       return () => {
-        if (alive) {
-          listeners[temp] = listeners[count];
-          listeners[count--] = void 0;
+        if (alive && subscribed) {
+          subscribed = false;
+          listeners[temp] = void 0;
+          while (count > 0 && !listeners[count - 1]) count--;
+          listeners.length = count;
         }
       };
     }
@@ -2840,25 +3233,42 @@ var SPECIAL_REFS = {
   [4]: {},
   [5]: {}
 };
-function isStream(value) {
+function isStream2(value) {
   return "__SEROVAL_STREAM__" in value;
 }
-function createStream() {
+function createStream2() {
   return STREAM_CONSTRUCTOR();
 }
-function createStreamFromAsyncIterable(iterable) {
-  const stream = createStream();
+function createStreamFromAsyncIterable(iterable, cleanups) {
+  const stream = createStream2();
   const iterator = iterable[SYM_ASYNC_ITERATOR]();
+  let cancelled = false;
+  let done = false;
+  cleanups === null || cleanups === void 0 || cleanups.push(() => {
+    if (!(done || cancelled)) {
+      cancelled = true;
+      Promise.resolve().then(() => {
+        var _iterator$return;
+        return (_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator);
+      }).catch(() => {
+      });
+    }
+  });
   async function push() {
     try {
-      const value = await iterator.next();
-      if (value.done) stream.return(value.value);
-      else {
+      while (!cancelled) {
+        const value = await iterator.next();
+        if (cancelled) return;
+        if (value.done) {
+          done = true;
+          stream.return(value.value);
+          break;
+        }
         stream.next(value.value);
-        await push();
       }
     } catch (error) {
-      stream.throw(error);
+      done = true;
+      if (!cancelled) stream.throw(error);
     }
   }
   push().catch(() => {
@@ -2877,13 +3287,15 @@ async function promiseToResult(current) {
   }
 }
 function createBaseParserContext(mode, options) {
+  var _options$compactArray;
   return {
     plugins: options.plugins,
     mode,
     marked: /* @__PURE__ */ new Set(),
     features: 127 ^ (options.disabledFeatures || 0),
     refs: options.refs || /* @__PURE__ */ new Map(),
-    depthLimit: options.depthLimit || 1e3
+    depthLimit: options.depthLimit || 1e3,
+    compactArrayBufferViews: (_options$compactArray = options.compactArrayBufferViews) !== null && _options$compactArray !== void 0 ? _options$compactArray : false
   };
 }
 function markParserRef(ctx, id) {
@@ -2950,11 +3362,22 @@ function createMapNode(ctx, id, k, v) {
 function createPromiseConstructorNode(ctx, id, resolver) {
   return createSerovalNode(22, id, resolver, void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 1), void 0, void 0, void 0);
 }
-function createArrayBufferNode(ctx, id, current) {
+function getArrayBufferView(ctx, current) {
+  if (!ctx.compactArrayBufferViews) return current;
+  const buffer = new Uint8Array(current.buffer, current.byteOffset, current.byteLength).slice().buffer;
+  const Constructor = current.constructor;
+  return new Constructor(buffer);
+}
+function encodeArrayBuffer(current) {
+  if (typeof Buffer !== "undefined") return Buffer.from(current).toString("base64");
   const bytes = new Uint8Array(current);
+  if (typeof bytes.toBase64 === "function") return bytes.toBase64();
   let result = "";
   for (let i = 0, len = bytes.length; i < len; i++) result += String.fromCharCode(bytes[i]);
-  return createSerovalNode(19, id, serializeString(btoa(result)), void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 5), void 0, void 0, void 0);
+  return btoa(result);
+}
+function createArrayBufferNode(ctx, id, current) {
+  return createSerovalNode(19, id, encodeArrayBuffer(current), void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 5), void 0, void 0, void 0);
 }
 function createAsyncParserContext(mode, options) {
   return {
@@ -3016,12 +3439,15 @@ async function parseBoxed$1(ctx, depth, id, current) {
   return createBoxedNode(id, await parseAsync(ctx, depth, current.valueOf()));
 }
 async function parseTypedArray$1(ctx, depth, id, current) {
+  current = getArrayBufferView(ctx.base, current);
   return createTypedArrayNode(id, current, await parseAsync(ctx, depth, current.buffer));
 }
 async function parseBigIntTypedArray$1(ctx, depth, id, current) {
+  current = getArrayBufferView(ctx.base, current);
   return createBigIntTypedArrayNode(id, current, await parseAsync(ctx, depth, current.buffer));
 }
 async function parseDataView$1(ctx, depth, id, current) {
+  current = getArrayBufferView(ctx.base, current);
   return createDataViewNode(id, current, await parseAsync(ctx, depth, current.buffer));
 }
 async function parseError$1(ctx, depth, id, current) {
@@ -3103,7 +3529,7 @@ async function parseSequence$1(ctx, depth, id, current) {
 }
 async function parseObjectAsync(ctx, depth, id, current) {
   if (Array.isArray(current)) return parseArray$1(ctx, depth, id, current);
-  if (isStream(current)) return parseStream$1(ctx, depth, id, current);
+  if (isStream2(current)) return parseStream$1(ctx, depth, id, current);
   if (isSequence(current)) return parseSequence$1(ctx, depth, id, current);
   let currentClass = current.constructor;
   if (currentClass !== void 0 && typeof currentClass !== "function") {
@@ -3293,7 +3719,8 @@ function isValidSymbol(symbol) {
       return false;
   }
 }
-var MAX_BASE64_LENGTH = 1e6;
+var DEFAULT_MAX_BASE64_LENGTH = 1e6;
+var MIN_NATIVE_BASE64_LENGTH = 512;
 var MAX_BIGINT_LENGTH = 1e4;
 var MAX_REGEXP_SOURCE_LENGTH = 2e4;
 function applyObjectFlag(obj, flag) {
@@ -3310,7 +3737,9 @@ function applyObjectFlag(obj, flag) {
 }
 var DEFAULT_DEPTH_LIMIT = 1e3;
 function createBaseDeserializerContext(mode, options) {
-  var _options$features;
+  var _options$maxBase64Len, _options$features;
+  const maxBase64Length = (_options$maxBase64Len = options.maxBase64Length) !== null && _options$maxBase64Len !== void 0 ? _options$maxBase64Len : DEFAULT_MAX_BASE64_LENGTH;
+  if (!Number.isSafeInteger(maxBase64Length) || maxBase64Length < 0) throw new RangeError("maxBase64Length must be a non-negative safe integer");
   const refs = options.refs || /* @__PURE__ */ new Map();
   if (!("types" in refs)) Object.assign(refs, { types: /* @__PURE__ */ new Map() });
   return {
@@ -3318,7 +3747,8 @@ function createBaseDeserializerContext(mode, options) {
     plugins: options.plugins,
     refs,
     features: (_options$features = options.features) !== null && _options$features !== void 0 ? _options$features : 127 ^ (options.disabledFeatures || 0),
-    depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT
+    depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT,
+    maxBase64Length
   };
 }
 function createVanillaDeserializerContext(options) {
@@ -3476,22 +3906,33 @@ function deserializeMap(ctx, depth, node) {
   return result;
 }
 function deserializeArrayBuffer(ctx, node) {
-  if (node.s.length > MAX_BASE64_LENGTH) throw new SerovalMalformedNodeError(node);
-  return assignIndexedValue$1(ctx, node.i, ARRAY_BUFFER_CONSTRUCTOR(deserializeString(node.s)));
+  if (typeof node.s !== "string") throw new SerovalMalformedNodeError(node);
+  if (node.s.length > ctx.base.maxBase64Length) throw new RangeError("ArrayBuffer exceeds maxBase64Length (" + ctx.base.maxBase64Length + ")");
+  const source = deserializeString(node.s);
+  let buffer;
+  if (source.length < MIN_NATIVE_BASE64_LENGTH || typeof Buffer === "undefined") buffer = ARRAY_BUFFER_CONSTRUCTOR(source);
+  else {
+    const decoded = atob(source);
+    buffer = new ArrayBuffer(decoded.length);
+    Buffer.from(buffer).write(decoded, "latin1");
+  }
+  return assignIndexedValue$1(ctx, node.i, buffer);
 }
 function deserializeTypedArray(ctx, depth, node) {
   var _node$b;
   const construct = getTypedArrayConstructor(node.c);
   const source = deserialize$1(ctx, depth, node.f);
+  if (!(source instanceof ArrayBuffer)) throw new SerovalMalformedNodeError(node);
   const offset = (_node$b = node.b) !== null && _node$b !== void 0 ? _node$b : 0;
-  if (offset < 0 || offset > source.byteLength || node.l > MAX_BASE64_LENGTH) throw new SerovalMalformedNodeError(node);
+  if (offset < 0 || offset > source.byteLength) throw new SerovalMalformedNodeError(node);
   return assignIndexedValue$1(ctx, node.i, new construct(source, offset, node.l));
 }
 function deserializeDataView(ctx, depth, node) {
   var _node$b2;
   const source = deserialize$1(ctx, depth, node.f);
+  if (!(source instanceof ArrayBuffer)) throw new SerovalMalformedNodeError(node);
   const offset = (_node$b2 = node.b) !== null && _node$b2 !== void 0 ? _node$b2 : 0;
-  if (offset < 0 || offset > source.byteLength || node.l > MAX_BASE64_LENGTH) throw new SerovalMalformedNodeError(node);
+  if (offset < 0 || offset > source.byteLength) throw new SerovalMalformedNodeError(node);
   return assignIndexedValue$1(ctx, node.i, new DataView(source, offset, node.l));
 }
 function deserializeDictionary(ctx, depth, node, result) {
@@ -3550,14 +3991,20 @@ function deserializePromiseFulfill(ctx, depth, node) {
 }
 function deserializeIteratorFactoryInstance(ctx, depth, node) {
   deserialize$1(ctx, depth, node.a[0]);
-  return sequenceToIterator(deserialize$1(ctx, depth, node.a[1]));
+  const source = deserialize$1(ctx, depth, node.a[1]);
+  validateNodeType(ctx, node, node.a[1].i, 35);
+  if (!source) throw new SerovalMalformedNodeError(node.a[1]);
+  return sequenceToIterator(source);
 }
 function deserializeAsyncIteratorFactoryInstance(ctx, depth, node) {
   deserialize$1(ctx, depth, node.a[0]);
-  return streamToAsyncIterable(deserialize$1(ctx, depth, node.a[1]));
+  const source = deserialize$1(ctx, depth, node.a[1]);
+  validateNodeType(ctx, node, node.a[1].i, 31);
+  if (!source) throw new SerovalMalformedNodeError(node.a[1]);
+  return streamToAsyncIterable(source);
 }
 function deserializeStreamConstructor(ctx, depth, node) {
-  const result = assignIndexedValue$1(ctx, node.i, createStream());
+  const result = assignIndexedValue$1(ctx, node.i, createStream2());
   assignNodeType(ctx, node.i, 31);
   const items = node.a;
   const len = items.length;
@@ -3599,6 +4046,7 @@ function deserializeAsyncIteratorFactory(ctx, depth, node) {
 }
 function deserializeSequence(ctx, depth, node) {
   const result = assignIndexedValue$1(ctx, node.i, createSequence([], node.s, node.l));
+  assignNodeType(ctx, node.i, 35);
   for (let i = 0, len = node.a.length; i < len; i++) result.v[i] = deserialize$1(ctx, depth, node.a[i]);
   return result;
 }
@@ -3768,7 +4216,7 @@ function parseProperties(ctx, depth, properties) {
   }
   if (SYM_ASYNC_ITERATOR in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));
-    valueNodes.push(createAsyncIteratorFactoryInstanceNode(parseAsyncIteratorFactory(ctx.base), parseSOS(ctx, depth, ctx.type === 1 ? createStream() : createStreamFromAsyncIterable(properties))));
+    valueNodes.push(createAsyncIteratorFactoryInstanceNode(parseAsyncIteratorFactory(ctx.base), parseSOS(ctx, depth, ctx.type === 1 ? createStream2() : createStreamFromAsyncIterable(properties, ctx.state.cleanups))));
   }
   if (SYM_TO_STRING_TAG in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));
@@ -3790,12 +4238,15 @@ function parseBoxed(ctx, depth, id, current) {
   return createBoxedNode(id, parseSOS(ctx, depth, current.valueOf()));
 }
 function parseTypedArray(ctx, depth, id, current) {
+  current = getArrayBufferView(ctx.base, current);
   return createTypedArrayNode(id, current, parseSOS(ctx, depth, current.buffer));
 }
 function parseBigIntTypedArray(ctx, depth, id, current) {
+  current = getArrayBufferView(ctx.base, current);
   return createBigIntTypedArrayNode(id, current, parseSOS(ctx, depth, current.buffer));
 }
 function parseDataView(ctx, depth, id, current) {
+  current = getArrayBufferView(ctx.base, current);
   return createDataViewNode(id, current, parseSOS(ctx, depth, current.buffer));
 }
 function parseError(ctx, depth, id, current) {
@@ -3964,7 +4415,7 @@ function parseObjectPhase2(ctx, depth, id, current, currentClass) {
 }
 function parseObject(ctx, depth, id, current) {
   if (Array.isArray(current)) return parseArray(ctx, depth, id, current);
-  if (isStream(current)) return parseStream(ctx, depth, id, current);
+  if (isStream2(current)) return parseStream(ctx, depth, id, current);
   if (isSequence(current)) return parseSequence(ctx, depth, id, current);
   let currentClass = current.constructor;
   if (currentClass !== void 0 && typeof currentClass !== "function") {
@@ -4062,15 +4513,19 @@ function destroyStreamParse(ctx) {
   }
 }
 async function toCrossJSONAsync(source, options = {}) {
+  const plugins = resolvePlugins(options.plugins);
   return await parseTopAsync(createAsyncParserContext(2, {
-    plugins: resolvePlugins(options.plugins),
+    compactArrayBufferViews: options.compactArrayBufferViews,
+    plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs
   }), source);
 }
 function toCrossJSONStream(source, options) {
+  const plugins = resolvePlugins(options.plugins);
   const ctx = createStreamParserContext({
-    plugins: resolvePlugins(options.plugins),
+    compactArrayBufferViews: options.compactArrayBufferViews,
+    plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
     depthLimit: options.depthLimit,
@@ -4087,15 +4542,18 @@ function fromJSON(source, options = {}) {
   const disabledFeatures = options.disabledFeatures || 0;
   const sourceFeatures = (_source$f = source.f) !== null && _source$f !== void 0 ? _source$f : 127;
   return deserializeTop(createVanillaDeserializerContext({
+    maxBase64Length: options.maxBase64Length,
     plugins,
     markedRefs: source.m,
     features: sourceFeatures & ~disabledFeatures,
     disabledFeatures
   }), source.t);
 }
-var textEncoder2 = new TextEncoder();
+var textEncoder$1 = new TextEncoder();
 var EMPTY_PAYLOAD = /* @__PURE__ */ new Uint8Array(0);
+var MAX_ERROR_MESSAGE_CODE_UNITS = 4096;
 function encodeFrame(type, streamId, payload) {
+  if (payload.byteLength > 16777216) throw new RangeError(`Frame payload exceeds ${MAX_FRAME_PAYLOAD_SIZE} bytes`);
   const frame = new Uint8Array(9 + payload.length);
   frame[0] = type;
   frame[1] = streamId >>> 24 & 255;
@@ -4109,119 +4567,303 @@ function encodeFrame(type, streamId, payload) {
   frame.set(payload, 9);
   return frame;
 }
-function encodeJSONFrame(json) {
-  return encodeFrame(FrameType.JSON, 0, textEncoder2.encode(json));
-}
-function encodeChunkFrame(streamId, chunk) {
-  return encodeFrame(FrameType.CHUNK, streamId, chunk);
-}
-function encodeEndFrame(streamId) {
-  return encodeFrame(FrameType.END, streamId, EMPTY_PAYLOAD);
-}
-function encodeErrorFrame(streamId, error) {
-  const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
-  return encodeFrame(FrameType.ERROR, streamId, textEncoder2.encode(message));
+function encodeErrorPayload(error) {
+  const originalMessage = error instanceof Error ? error.message : String(error ?? "Unknown error");
+  const message = originalMessage.length > MAX_ERROR_MESSAGE_CODE_UNITS ? `${originalMessage.slice(0, MAX_ERROR_MESSAGE_CODE_UNITS)}\u2026` : originalMessage;
+  return textEncoder$1.encode(message);
 }
-function createMultiplexedStream(jsonStream, rawStreams, lateStreamSource) {
+function createMultiplexedStream(recordStream, options = {}) {
   let controller;
-  let cancelled = false;
-  const readers = [];
-  const enqueue = (frame) => {
-    if (cancelled) return false;
+  let stopped = false;
+  let activePumps = 0;
+  let wakeDemand;
+  let admission;
+  const readers = /* @__PURE__ */ new Set();
+  const pendingRawStreams = /* @__PURE__ */ new Set();
+  const abortOutput = () => errorOutput(options.signal?.reason);
+  const wakeAdmission = () => {
+    const wake = wakeDemand;
+    wakeDemand = void 0;
+    wake?.();
+  };
+  const cancelReader2 = (reader, reason) => {
+    reader.cancel(reason).catch(() => {
+    });
+  };
+  const cancelStream = (stream, reason) => {
+    stream.cancel(reason).catch(() => {
+    });
+  };
+  const stop = (reason) => {
+    if (stopped) return false;
+    stopped = [reason];
+    options.signal?.removeEventListener("abort", abortOutput);
+    wakeAdmission();
+    for (const reader of readers) cancelReader2(reader, reason);
+    for (const stream of pendingRawStreams) cancelStream(stream, reason);
+    pendingRawStreams.clear();
+    return true;
+  };
+  const errorOutput = (error) => {
+    if (!stop(error)) return;
     try {
-      controller.enqueue(frame);
-      return true;
+      controller.error(error);
     } catch {
-      return false;
     }
   };
-  const errorOutput = (error) => {
-    if (cancelled) return;
-    cancelled = true;
+  const waitForDemand = async () => {
+    while (!stopped && (controller.desiredSize ?? 0) <= 0) await new Promise((resolve) => {
+      wakeDemand = resolve;
+    });
+    return !stopped;
+  };
+  const admitFrame = (type, streamId, payload) => {
+    if (stopped) return false;
+    if (!admission && (controller.desiredSize ?? 0) > 0) {
+      controller.enqueue(encodeFrame(type, streamId, payload));
+      return true;
+    }
+    const runAdmission = async () => {
+      if (!await waitForDemand()) return false;
+      controller.enqueue(encodeFrame(type, streamId, payload));
+      return true;
+    };
+    const result = admission ? admission.then(runAdmission) : runAdmission();
+    const clearAdmission = () => {
+      if (admission === tail) admission = void 0;
+    };
+    const tail = result.then(clearAdmission, clearAdmission);
+    admission = tail;
+    return result;
+  };
+  const maybeClose = () => {
+    if (activePumps !== 0 || !stop()) return;
     try {
-      controller.error(error);
+      controller.close();
     } catch {
     }
-    for (const reader of readers) reader.cancel().catch(() => {
-    });
   };
-  async function pumpRawStream(streamId, stream) {
-    const reader = stream.getReader();
-    readers.push(reader);
-    try {
-      while (!cancelled) {
-        const { done, value } = await reader.read();
-        if (done) {
-          enqueue(encodeEndFrame(streamId));
-          return;
-        }
-        if (!enqueue(encodeChunkFrame(streamId, value))) return;
-      }
-    } catch (error) {
-      enqueue(encodeErrorFrame(streamId, error));
-    } finally {
-      reader.releaseLock();
-    }
+  const startPump = (pump) => {
+    activePumps++;
+    pump().then(() => {
+      activePumps--;
+      maybeClose();
+    }, (error) => {
+      activePumps--;
+      errorOutput(error);
+    });
+  };
+  async function pumpRawStream(streamId, stream) {
+    const reader = stream.getReader();
+    readers.add(reader);
+    try {
+      while (!stopped) {
+        const { done, value } = await reader.read();
+        if (stopped) return;
+        if (done) {
+          const frameAdmission = admitFrame(2, streamId, EMPTY_PAYLOAD);
+          if (frameAdmission !== true) await frameAdmission;
+          return;
+        }
+        if (!(value instanceof Uint8Array)) throw new TypeError("RawStream chunks must be Uint8Array");
+        let offset = 0;
+        do {
+          const frameAdmission = admitFrame(1, streamId, value.byteLength <= 16777216 ? value : value.subarray(offset, offset + MAX_FRAME_PAYLOAD_SIZE));
+          if (frameAdmission !== true && (frameAdmission === false || !await frameAdmission)) return;
+          offset += MAX_FRAME_PAYLOAD_SIZE;
+        } while (offset < value.byteLength);
+      }
+    } catch (error) {
+      if (!stopped) {
+        const frameAdmission = admitFrame(3, streamId, encodeErrorPayload(error));
+        if (frameAdmission !== true) await frameAdmission;
+      }
+    } finally {
+      readers.delete(reader);
+      reader.releaseLock();
+    }
+  }
+  async function pumpRecords() {
+    const reader = recordStream.getReader();
+    readers.add(reader);
+    try {
+      while (!stopped) {
+        const { done, value } = await reader.read();
+        if (stopped) {
+          if (!done) for (const registration of value.rawStreams) cancelStream(registration.stream, stopped[0]);
+          return;
+        }
+        if (done) return;
+        for (const registration of value.rawStreams) pendingRawStreams.add(registration.stream);
+        const frameAdmission = admitFrame(0, 0, value.json);
+        if (frameAdmission !== true && (frameAdmission === false || !await frameAdmission)) return;
+        for (const registration of value.rawStreams) {
+          pendingRawStreams.delete(registration.stream);
+          startPump(pumpRawStream.bind(void 0, registration.id, registration.stream));
+        }
+      }
+    } catch (error) {
+      if (!stopped) errorOutput(error);
+    } finally {
+      readers.delete(reader);
+      reader.releaseLock();
+    }
+  }
+  return new ReadableStream({
+    start(ctrl) {
+      controller = ctrl;
+      if (options.signal?.aborted) {
+        cancelStream(recordStream, options.signal.reason);
+        errorOutput(options.signal.reason);
+        return;
+      }
+      options.signal?.addEventListener("abort", abortOutput, { once: true });
+      startPump(pumpRecords);
+    },
+    pull() {
+      wakeAdmission();
+    },
+    cancel(reason) {
+      if (stop(reason)) options.onCancel?.(reason);
+    }
+  });
+}
+function isSafeKey(key) {
+  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+function safeObjectMerge(target, source) {
+  const result = /* @__PURE__ */ Object.create(null);
+  if (target) {
+    for (const key of Object.keys(target)) if (isSafeKey(key)) result[key] = target[key];
+  }
+  if (source && typeof source === "object") {
+    for (const key of Object.keys(source)) if (isSafeKey(key)) result[key] = source[key];
+  }
+  return result;
+}
+function createNullProtoObject(source) {
+  if (!source) return /* @__PURE__ */ Object.create(null);
+  const obj = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(source)) if (isSafeKey(key)) obj[key] = source[key];
+  return obj;
+}
+function flattenMiddlewares(middlewares, maxDepth = 100) {
+  const seen = /* @__PURE__ */ new Set();
+  const flattened = [];
+  const recurse = (middleware, depth) => {
+    if (depth > maxDepth) throw new Error(`Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`);
+    middleware.forEach((m) => {
+      if (m.options.middleware) recurse(m.options.middleware, depth + 1);
+      if (!seen.has(m)) {
+        seen.add(m);
+        flattened.push(m);
+      }
+    });
+  };
+  recurse(middlewares, 0);
+  return flattened;
+}
+var createMiddleware = (options, __opts) => {
+  const resolvedOptions = {
+    type: "request",
+    ...__opts || options
+  };
+  const setValidator = (validator) => {
+    return createMiddleware({}, Object.assign(resolvedOptions, {
+      validator,
+      inputValidator: validator
+    }));
+  };
+  return {
+    options: resolvedOptions,
+    middleware: (middleware) => {
+      return createMiddleware({}, Object.assign(resolvedOptions, { middleware }));
+    },
+    validator: setValidator,
+    inputValidator: setValidator,
+    client: (client) => {
+      return createMiddleware({}, Object.assign(resolvedOptions, { client }));
+    },
+    server: (server) => {
+      return createMiddleware({}, Object.assign(resolvedOptions, { server }));
+    }
+  };
+};
+var innerCreateCsrfMiddleware = (opts = {}) => {
+  return createMiddleware().server(async (ctx) => {
+    const csrfCtx = ctx;
+    if (opts.filter && !await opts.filter(csrfCtx)) return ctx.next();
+    if (await isCsrfRequestAllowed(opts, csrfCtx)) return ctx.next();
+    return getFailureResponse(opts, csrfCtx);
+  });
+};
+var createCsrfMiddleware = innerCreateCsrfMiddleware;
+async function isCsrfRequestAllowed(opts, ctx) {
+  const result = await getCsrfRequestValidationResult(opts, ctx);
+  return result === true || result === void 0 && opts.allowRequestsWithoutOriginCheck === true;
+}
+async function getCsrfRequestValidationResult(opts, ctx) {
+  const fetchSite = ctx.request.headers.get("Sec-Fetch-Site");
+  if (fetchSite !== null) return matchValue(opts.secFetchSite ?? "same-origin", fetchSite, ctx);
+  const origin = ctx.request.headers.get("Origin");
+  if (origin !== null) {
+    if (opts.origin) return matchValue(opts.origin, origin, ctx);
+    return origin === new URL(ctx.request.url).origin;
   }
-  async function pumpJSON() {
-    const reader = jsonStream.getReader();
-    readers.push(reader);
-    try {
-      while (!cancelled) {
-        const { done, value } = await reader.read();
-        if (done) return;
-        if (!enqueue(encodeJSONFrame(value))) return;
-      }
-    } catch (error) {
-      errorOutput(error);
-      throw error;
-    } finally {
-      reader.releaseLock();
-    }
+  const referer = ctx.request.headers.get("Referer");
+  if (referer === null || opts.referer === false) return;
+  if (typeof opts.referer === "function") return opts.referer(referer, ctx);
+  if (opts.origin) {
+    const refererOrigin = getOriginFromUrl(referer);
+    return refererOrigin !== void 0 && matchValue(opts.origin, refererOrigin, ctx);
   }
-  async function pumpLateStreams() {
-    if (!lateStreamSource) return [];
-    const lateStreamPumps = [];
-    const reader = lateStreamSource.getReader();
-    readers.push(reader);
-    try {
-      while (!cancelled) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        lateStreamPumps.push(pumpRawStream(value.id, value.stream));
-      }
-    } finally {
-      reader.releaseLock();
-    }
-    return lateStreamPumps;
+  return isRefererSameOrigin(referer, new URL(ctx.request.url).origin);
+}
+async function matchValue(matcher, value, ctx) {
+  if (typeof matcher === "function") return matcher(value, ctx);
+  if (Array.isArray(matcher)) return matcher.includes(value);
+  return value === matcher;
+}
+function getOriginFromUrl(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return;
   }
-  return new ReadableStream({
-    async start(ctrl) {
-      controller = ctrl;
-      const pumps = [pumpJSON()];
-      for (const [streamId, stream] of rawStreams) pumps.push(pumpRawStream(streamId, stream));
-      if (lateStreamSource) pumps.push(pumpLateStreams());
-      try {
-        const latePumps = (await Promise.all(pumps)).find(Array.isArray);
-        if (latePumps && latePumps.length > 0) await Promise.all(latePumps);
-        if (!cancelled) try {
-          controller.close();
-        } catch {
-        }
-      } catch {
-      }
-    },
-    cancel() {
-      cancelled = true;
-      for (const reader of readers) reader.cancel().catch(() => {
-      });
-      readers.length = 0;
-    }
-  });
+}
+function isRefererSameOrigin(referer, requestOrigin) {
+  if (referer === requestOrigin) return true;
+  if (!referer.startsWith(requestOrigin)) return false;
+  if (referer.length === requestOrigin.length) return true;
+  const code = referer.charCodeAt(requestOrigin.length);
+  return code === 47 || code === 63 || code === 35;
+}
+async function getFailureResponse(opts, ctx) {
+  if (typeof opts.failureResponse === "function") return opts.failureResponse(ctx);
+  return opts.failureResponse?.clone() ?? new Response("Forbidden", { status: 403 });
 }
 var serovalPlugins = void 0;
 var FORM_DATA_CONTENT_TYPES = ["multipart/form-data", "application/x-www-form-urlencoded"];
 var MAX_PAYLOAD_SIZE = 1e6;
+var MAX_PENDING_SERIALIZATION_RECORDS = 1024;
+var MAX_PENDING_SERIALIZATION_BYTES = 33554432;
+var textEncoder3 = new TextEncoder();
+function encodeSerializationRecord(value) {
+  return textEncoder3.encode(JSON.stringify(value));
+}
+function exceedsPendingSerializationLimit(record, recordCount, pendingBytes) {
+  return recordCount >= MAX_PENDING_SERIALIZATION_RECORDS || pendingBytes + record.byteLength > MAX_PENDING_SERIALIZATION_BYTES;
+}
+function runSerializationCleanup(dispose) {
+  try {
+    dispose();
+  } catch {
+  }
+}
+function cancelRawStream(stream, reason) {
+  stream.cancel(reason).catch(() => {
+  });
+}
 var handleServerAction = async ({ request, context, serverFnId }) => {
   const methodUpper = request.method.toUpperCase();
   const url = new URL(request.url);
@@ -4231,192 +4873,260 @@ var handleServerAction = async ({ request, context, serverFnId }) => {
     headers: { Allow: action.method }
   });
   const isServerFn = request.headers.get("x-tsr-serverFn") === "true";
-  if (!serovalPlugins) serovalPlugins = getDefaultSerovalPlugins();
+  serovalPlugins ??= getSerovalPlugins(defaultSerovalDeserializerPlugins);
   const contentType = request.headers.get("Content-Type");
-  function parsePayload(payload) {
-    return fromJSON(payload, { plugins: serovalPlugins });
-  }
-  return await (async () => {
-    try {
-      let serializeResult2 = function(res2) {
-        let nonStreamingBody = void 0;
-        const alsResponse = getResponse();
-        if (res2 !== void 0) {
-          const rawStreams = /* @__PURE__ */ new Map();
-          let initialPhase = true;
-          let lateStreamWriter;
-          let lateStreamReadable = void 0;
-          const pendingLateStreams = [];
-          const plugins = [createRawStreamRPCPlugin((id, stream) => {
-            if (initialPhase) {
-              rawStreams.set(id, stream);
-              return;
-            }
-            if (lateStreamWriter) {
-              lateStreamWriter.write({
-                id,
-                stream
-              }).catch(() => {
-              });
-              return;
-            }
-            pendingLateStreams.push({
-              id,
-              stream
-            });
-          }), ...serovalPlugins || []];
-          let done = false;
-          const callbacks = {
-            onParse: (value) => {
-              nonStreamingBody = value;
-            },
-            onDone: () => {
-              done = true;
-            },
-            onError: (error) => {
-              throw error;
-            }
-          };
-          toCrossJSONStream(res2, {
-            refs: /* @__PURE__ */ new Map(),
-            plugins,
-            onParse(value) {
-              callbacks.onParse(value);
-            },
-            onDone() {
-              callbacks.onDone();
-            },
-            onError: (error) => {
-              callbacks.onError(error);
-            }
-          });
-          initialPhase = false;
-          if (done && rawStreams.size === 0) return new Response(nonStreamingBody ? JSON.stringify(nonStreamingBody) : void 0, {
-            status: alsResponse.status,
-            statusText: alsResponse.statusText,
-            headers: {
-              "Content-Type": "application/json",
-              [X_TSS_SERIALIZED]: "true"
-            }
-          });
-          const { readable, writable } = new TransformStream();
-          lateStreamReadable = readable;
-          lateStreamWriter = writable.getWriter();
-          for (const registration of pendingLateStreams) lateStreamWriter.write(registration).catch(() => {
-          });
-          pendingLateStreams.length = 0;
-          const multiplexedStream = createMultiplexedStream(new ReadableStream({
-            start(controller) {
-              callbacks.onParse = (value) => {
-                controller.enqueue(JSON.stringify(value) + "\n");
-              };
-              callbacks.onDone = () => {
-                try {
-                  controller.close();
-                } catch {
-                }
-                lateStreamWriter?.close().catch(() => {
-                }).finally(() => {
-                  lateStreamWriter = void 0;
-                });
-              };
-              callbacks.onError = (error) => {
-                controller.error(error);
-                lateStreamWriter?.abort(error).catch(() => {
-                }).finally(() => {
-                  lateStreamWriter = void 0;
-                });
-              };
-              if (nonStreamingBody !== void 0) callbacks.onParse(nonStreamingBody);
-              if (done) callbacks.onDone();
-            },
-            cancel() {
-              lateStreamWriter?.abort().catch(() => {
-              });
-              lateStreamWriter = void 0;
-            }
-          }), rawStreams, lateStreamReadable);
-          return new Response(multiplexedStream, {
-            status: alsResponse.status,
-            statusText: alsResponse.statusText,
-            headers: {
-              "Content-Type": TSS_CONTENT_TYPE_FRAMED_VERSIONED,
-              [X_TSS_SERIALIZED]: "true"
-            }
-          });
-        }
-        return new Response(void 0, {
-          status: alsResponse.status,
-          statusText: alsResponse.statusText
-        });
+  try {
+    let res;
+    if (FORM_DATA_CONTENT_TYPES.some((type) => contentType && contentType.includes(type))) {
+      if (methodUpper === "GET") invariant();
+      const formData = await request.formData();
+      const serializedContext = formData.get(TSS_FORMDATA_CONTEXT);
+      formData.delete(TSS_FORMDATA_CONTEXT);
+      const params = {
+        context,
+        data: formData,
+        method: methodUpper
       };
-      var serializeResult = serializeResult2;
-      let res = await (async () => {
-        if (FORM_DATA_CONTENT_TYPES.some((type) => contentType && contentType.includes(type))) {
-          if (methodUpper === "GET") invariant();
-          const formData = await request.formData();
-          const serializedContext = formData.get(TSS_FORMDATA_CONTEXT);
-          formData.delete(TSS_FORMDATA_CONTEXT);
-          const params = {
-            context,
-            data: formData,
-            method: methodUpper
-          };
-          if (typeof serializedContext === "string") try {
-            const deserializedContext = fromJSON(JSON.parse(serializedContext), { plugins: serovalPlugins });
-            if (typeof deserializedContext === "object" && deserializedContext) params.context = safeObjectMerge(deserializedContext, context);
-          } catch (e) {
-          }
-          return await action(params);
-        }
-        if (methodUpper === "GET") {
-          const payloadParam = url.searchParams.get("payload");
-          if (payloadParam && payloadParam.length > MAX_PAYLOAD_SIZE) throw new Error("Payload too large");
-          const payload2 = payloadParam ? parsePayload(JSON.parse(payloadParam)) : {};
-          payload2.context = safeObjectMerge(payload2.context, context);
-          payload2.method = methodUpper;
-          return await action(payload2);
-        }
-        let jsonPayload;
-        if (contentType?.includes("application/json")) jsonPayload = await request.json();
-        const payload = jsonPayload ? parsePayload(jsonPayload) : {};
-        payload.context = safeObjectMerge(payload.context, context);
-        payload.method = methodUpper;
-        return await action(payload);
-      })();
-      const unwrapped = res.result || res.error;
-      if (isNotFound(res)) res = isNotFoundResponse(res);
-      if (!isServerFn) return unwrapped;
-      if (unwrapped instanceof Response) {
-        if (isRedirect(unwrapped)) return unwrapped;
-        unwrapped.headers.set(X_TSS_RAW_RESPONSE, "true");
-        return unwrapped;
+      if (typeof serializedContext === "string") try {
+        const deserializedContext = fromJSON(JSON.parse(serializedContext), { plugins: serovalPlugins });
+        if (typeof deserializedContext === "object" && deserializedContext) params.context = safeObjectMerge(deserializedContext, context);
+      } catch (e) {
       }
-      return serializeResult2(res);
-    } catch (error) {
-      if (error instanceof Response) return error;
-      if (isNotFound(error)) return isNotFoundResponse(error);
-      console.info();
-      console.info("Server Fn Error!");
-      console.info();
-      console.error(error);
-      console.info();
-      const serializedError = JSON.stringify(await Promise.resolve(toCrossJSONAsync(error, {
-        refs: /* @__PURE__ */ new Map(),
-        plugins: serovalPlugins
-      })));
-      const response = getResponse();
+      res = await action(params);
+    } else if (methodUpper === "GET") {
+      const payloadParam = url.searchParams.get("payload");
+      if (payloadParam && payloadParam.length > MAX_PAYLOAD_SIZE) throw new Error("Payload too large");
+      const payload = payloadParam ? fromJSON(JSON.parse(payloadParam), { plugins: serovalPlugins }) : {};
+      payload.context = safeObjectMerge(payload.context, context);
+      payload.method = methodUpper;
+      res = await action(payload);
+    } else {
+      const payload = contentType?.includes("application/json") ? fromJSON(await request.json(), { plugins: serovalPlugins }) : {};
+      payload.context = safeObjectMerge(payload.context, context);
+      payload.method = methodUpper;
+      res = await action(payload);
+    }
+    const unwrapped = res.result !== void 0 ? res.result : res.error;
+    if (isNotFound(res)) res = isNotFoundResponse(res);
+    if (!isServerFn) return unwrapped;
+    if (unwrapped instanceof Response) {
+      if (isRedirect(unwrapped)) return unwrapped;
+      unwrapped.headers.set(X_TSS_RAW_RESPONSE, "true");
+      return unwrapped;
+    }
+    return serializeResult(res, request.signal, serovalPlugins);
+  } catch (error) {
+    if (error instanceof Response) return error;
+    if (isNotFound(error)) return isNotFoundResponse(error);
+    console.error("Server Fn Error!", error);
+    const serializedError = JSON.stringify(await toCrossJSONAsync(error, {
+      refs: /* @__PURE__ */ new Map(),
+      plugins: serovalPlugins
+    }));
+    const response = getResponse();
+    const headers = {
+      "Content-Type": "application/json",
+      [X_TSS_SERIALIZED]: "true"
+    };
+    try {
       return new Response(serializedError, {
         status: response.status ?? 500,
         statusText: response.statusText,
+        headers
+      });
+    } catch {
+      return new Response(serializedError, {
+        status: 500,
+        statusText: "",
+        headers
+      });
+    }
+  }
+};
+function serializeResult(res, signal, plugins) {
+  const alsResponse = getResponse();
+  const initialRecords = [];
+  let initialBytes = 0;
+  const pendingRawStreams = [];
+  let done = false;
+  let initialParsed = false;
+  let serializationFailure;
+  let disposeSerialization;
+  let onParse2 = (value, initial) => {
+    if (serializationFailure) return;
+    initialParsed ||= initial;
+    const record = encodeSerializationRecord(value);
+    if (exceedsPendingSerializationLimit(record, initialRecords.length, initialBytes)) {
+      serializationFailure = [/* @__PURE__ */ new Error("Server function serialization exceeded its pending output limit")];
+      return;
+    }
+    initialRecords.push(record);
+    initialBytes += record.byteLength;
+  };
+  let onDone2 = () => {
+    if (initialParsed) done = true;
+  };
+  let onError2 = (error) => {
+    serializationFailure ??= [error];
+  };
+  const rawStreamPlugin = createRawStreamRPCPlugin((id, stream) => {
+    if (serializationFailure) {
+      cancelRawStream(stream, serializationFailure[0]);
+      return;
+    }
+    if (id > 1024) {
+      const error = /* @__PURE__ */ new Error(`Too many raw streams in framed response (max ${MAX_FRAMED_STREAMS})`);
+      cancelRawStream(stream, error);
+      onError2(error);
+      return;
+    }
+    pendingRawStreams.push({
+      id,
+      stream
+    });
+  });
+  const dispose = toCrossJSONStream(res, {
+    refs: /* @__PURE__ */ new Map(),
+    plugins: [rawStreamPlugin, ...plugins],
+    onParse(value, initial) {
+      onParse2(value, initial);
+    },
+    onDone() {
+      onDone2();
+    },
+    onError: (error) => {
+      onError2(error);
+    }
+  });
+  if (serializationFailure) {
+    runSerializationCleanup(dispose);
+    for (const registration of pendingRawStreams) cancelRawStream(registration.stream, serializationFailure[0]);
+    throw serializationFailure[0];
+  }
+  if (!done) disposeSerialization = dispose;
+  if (done && pendingRawStreams.length === 0 && initialRecords.length === 1) return new Response(initialRecords[0], {
+    status: alsResponse.status,
+    statusText: alsResponse.statusText,
+    headers: {
+      "Content-Type": "application/json",
+      [X_TSS_SERIALIZED]: "true"
+    }
+  });
+  if (done && initialRecords.length === 1) {
+    const json = initialRecords[0];
+    if (json.byteLength > 16777216) {
+      const error = /* @__PURE__ */ new Error("Server function serialization exceeded its pending output limit");
+      for (const registration of pendingRawStreams) cancelRawStream(registration.stream, error);
+      throw error;
+    }
+    const rawStreams = pendingRawStreams.splice(0);
+    initialRecords.length = 0;
+    return createFramedResponse(new ReadableStream({
+      start(controller) {
+        controller.enqueue({
+          json,
+          rawStreams
+        });
+        controller.close();
+      },
+      cancel(reason) {
+        for (const registration of rawStreams) cancelRawStream(registration.stream, reason);
+      }
+    }), { signal });
+  }
+  const { readable, writable } = new TransformStream();
+  const writer = writable.getWriter();
+  const recordAbortController = new AbortController();
+  let pendingBytes = 0;
+  const pendingRecords = /* @__PURE__ */ new Set();
+  const abortRecordStream = (error) => {
+    if (serializationFailure) return;
+    serializationFailure = [error];
+    const disposeCurrentSerialization = disposeSerialization;
+    disposeSerialization = void 0;
+    for (const registration of pendingRawStreams.splice(0)) cancelRawStream(registration.stream, error);
+    for (const record of pendingRecords) for (const registration of record.rawStreams) cancelRawStream(registration.stream, error);
+    pendingRecords.clear();
+    recordAbortController.abort(error);
+    writer.abort(error).catch(() => {
+    });
+    if (disposeCurrentSerialization) runSerializationCleanup(disposeCurrentSerialization);
+  };
+  const writeRecord = (json, rawStreams) => {
+    if (serializationFailure) {
+      for (const registration of rawStreams) cancelRawStream(registration.stream, serializationFailure[0]);
+      return false;
+    }
+    if (json.byteLength > 16777216 || exceedsPendingSerializationLimit(json, pendingRecords.size, pendingBytes)) {
+      const error = /* @__PURE__ */ new Error("Server function serialization exceeded its pending output limit");
+      for (const registration of rawStreams) cancelRawStream(registration.stream, error);
+      onError2(error);
+      return false;
+    }
+    pendingBytes += json.byteLength;
+    const record = {
+      json,
+      rawStreams
+    };
+    pendingRecords.add(record);
+    writer.write(record).then(() => {
+      pendingRecords.delete(record);
+      pendingBytes -= json.byteLength;
+    }, (error) => {
+      const stillOwned = pendingRecords.delete(record);
+      pendingBytes -= json.byteLength;
+      if (stillOwned) for (const registration of rawStreams) cancelRawStream(registration.stream, error);
+    });
+    return true;
+  };
+  onParse2 = (value) => {
+    if (serializationFailure) return;
+    writeRecord(encodeSerializationRecord(value), pendingRawStreams.splice(0));
+  };
+  onDone2 = () => {
+    if (serializationFailure) return;
+    disposeSerialization = void 0;
+    writer.close().catch(() => {
+    });
+  };
+  onError2 = (error) => {
+    abortRecordStream(error);
+  };
+  const initialRawStreams = pendingRawStreams.splice(0);
+  for (let index = 0; index < initialRecords.length; index++) {
+    const isLast = index === initialRecords.length - 1;
+    if (!writeRecord(initialRecords[index], isLast ? initialRawStreams : [])) {
+      if (!isLast) for (const registration of initialRawStreams) cancelRawStream(registration.stream, serializationFailure[0]);
+      initialRecords.length = 0;
+      throw serializationFailure[0];
+    }
+  }
+  initialRecords.length = 0;
+  if (done) onDone2();
+  writer.closed.catch((error) => {
+    abortRecordStream(error);
+  });
+  return createFramedResponse(readable, {
+    signal: AbortSignal.any([recordAbortController.signal, signal]),
+    onCancel: abortRecordStream
+  });
+  function createFramedResponse(records, options) {
+    const multiplexedStream = createMultiplexedStream(records, options);
+    try {
+      return new Response(multiplexedStream, {
+        status: alsResponse.status,
+        statusText: alsResponse.statusText,
         headers: {
-          "Content-Type": "application/json",
+          "Content-Type": TSS_CONTENT_TYPE_FRAMED_VERSIONED,
           [X_TSS_SERIALIZED]: "true"
         }
       });
+    } catch (error) {
+      cancelRawStream(multiplexedStream, error);
+      throw error;
     }
-  })();
-};
+  }
+}
 function isNotFoundResponse(error) {
   const { headers, ...rest } = error;
   return new Response(JSON.stringify(rest), {
@@ -4982,9 +5692,9 @@ var getBaseManifest = getProdBaseManifest;
 var createEarlyHintsForRequest = createEarlyHintsCollector;
 async function loadEntries() {
   const [routerEntry, startEntry, pluginAdapters] = await Promise.all([
-    import("./router-C437aaqv-72HBLLJI.js").then((n) => n.t),
-    import("./start-QK6aG02q-EMREW2SB.js"),
-    import("./empty-plugin-adapters-Cqtvkauv-ILKI7W7V.js")
+    import("./router-UgU5vJxm-R33FGTXY.js").then((n) => n.t),
+    import("./start-DEejK9Uj-FODAOTAO.js"),
+    import("./empty-plugin-adapters-DOl-E2pL-RKRSN75W.js")
   ]);
   return {
     routerEntry,
@@ -5009,65 +5719,76 @@ function throwRouteHandlerError() {
 function throwIfMayNotDefer() {
   throw new Error(ERR_NO_DEFER);
 }
-function isSpecialResponse(value) {
-  return value instanceof Response || isRedirect(value);
+function getResponseFromResult(result) {
+  return isSsrResponse(result) || result instanceof Response ? result : result?.response;
 }
-function handleCtxResult(result) {
-  if (isSsrResponse(result) || isSpecialResponse(result)) return { response: result };
-  return result;
+var responseBodySources = /* @__PURE__ */ new WeakMap();
+function disposeResponseResult(result, reason) {
+  const response = getResponseFromResult(result);
+  if (isSsrResponse(response) || response instanceof Response) disposeSsrResponse(response, reason);
+}
+function hasResponseBody(value) {
+  return value instanceof Response && value.body !== null;
+}
+function inheritsResponseOwnership(ownership, candidate) {
+  return hasResponseBody(candidate) && (candidate.body === ownership.response.body || responseBodySources.get(candidate) === ownership.response);
 }
-function disposeLateResponse(result, signal) {
-  const response = handleCtxResult(result)?.response;
-  if (isSsrResponse(response) || isSpecialResponse(response)) disposeSsrResponseDetached(response, signal.reason);
+function disposeResponseOwnership(ownership, reason) {
+  const { response, sourceBody, streamResponse } = ownership;
+  streamResponse?.dispose(reason);
+  if (!streamResponse || response.body !== sourceBody) response.body.cancel(reason).catch(() => {
+  });
+}
+function getOwnedResponse(ownership) {
+  const { response, sourceBody, streamResponse } = ownership;
+  if (!streamResponse) return response;
+  if (streamResponse.response === response && response.body === sourceBody) return streamResponse;
+  if (response.body === sourceBody) return {
+    ...streamResponse,
+    response
+  };
+  return {
+    ...streamResponse,
+    response,
+    dispose(reason) {
+      disposeResponseOwnership(ownership, reason);
+    }
+  };
 }
-function isSignalAborted(signal) {
-  return signal.aborted;
+function createLateResponseDisposer(signal) {
+  return (result) => disposeResponseResult(result, signal.reason);
 }
-async function executeMiddleware(middlewares, ctx, signal) {
+async function executeMiddleware(middlewares, terminal, ctx, signal, terminalNext) {
   let index = -1;
-  let streamResponse;
-  let retiredStreamIdentities;
-  const isResponseAlias = (candidate, response) => candidate === response || candidate instanceof Response && response.body !== null && candidate.body === response.body;
+  let responseOwnership;
+  let settled = false;
+  const disposeAbandonedResult = createLateResponseDisposer(signal);
   const setResponse = (response) => {
-    if (isSsrResponse(response)) {
-      if (response.serverSsrCleanup === "stream") streamResponse = response;
-      ctx.response = response.response;
+    const ssrResponse = isSsrResponse(response) ? response : void 0;
+    const streamResponse = ssrResponse?.serverSsrCleanup === "stream" ? ssrResponse : void 0;
+    const exposed = ssrResponse ? ssrResponse.response : response;
+    const current = responseOwnership;
+    if (settled) {
+      if (exposed !== ctx.response) disposeResponseResult(response, "late middleware response");
       return;
     }
-    ctx.response = response;
-  };
-  const disposeStreamResponse = async (reason) => {
-    const response = streamResponse;
-    if (!response) return;
-    streamResponse = void 0;
-    retiredStreamIdentities ??= /* @__PURE__ */ new WeakSet();
-    retiredStreamIdentities.add(response.response);
-    if (response.response.body) retiredStreamIdentities.add(response.response.body);
-    const currentResponse = ctx.response;
-    if (isResponseAlias(currentResponse, response.response)) ctx.response = void 0;
-    await response.dispose(reason);
-  };
-  const disposeAbandonedResult = (result) => {
-    const exposed = handleCtxResult(result)?.response;
-    const response = isSsrResponse(exposed) ? exposed.response : exposed;
-    if (streamResponse && isResponseAlias(response, streamResponse.response)) {
-      disposeStreamResponse(signal.reason).catch(console.error);
-      return;
+    if (current && current.response === exposed) current.streamResponse ??= streamResponse;
+    else if (current && inheritsResponseOwnership(current, exposed)) {
+      current.response = exposed;
+      current.streamResponse ??= streamResponse;
+    } else {
+      if (current) disposeResponseOwnership(current, "middleware response replaced");
+      if (hasResponseBody(exposed)) responseOwnership = {
+        response: exposed,
+        sourceBody: exposed.body,
+        streamResponse
+      };
+      else responseOwnership = void 0;
     }
-    if (response instanceof Response && retiredStreamIdentities && (retiredStreamIdentities.has(response) || response.body !== null && retiredStreamIdentities.has(response.body))) return;
-    disposeLateResponse(result, signal);
+    ctx.response = exposed;
   };
-  const getFinalResponse = async () => {
-    const response = ctx.response;
-    if (!response) throwRouteHandlerError();
-    if (!streamResponse) return response;
-    if (response === streamResponse.response) return streamResponse;
-    if (streamResponse.response.body !== null && response.body === streamResponse.response.body) return {
-      ...streamResponse,
-      response
-    };
-    await disposeStreamResponse("middleware response replaced");
-    return response;
+  const reconcileCtxResponse = () => {
+    if (ctx.response !== responseOwnership?.response) setResponse(ctx.response);
   };
   let nextPromise;
   function next(nextCtx) {
@@ -5076,73 +5797,68 @@ async function executeMiddleware(middlewares, ctx, signal) {
     return result;
   }
   async function runNext(nextCtx) {
-    if (signal.aborted) throw signal.reason;
+    signal.throwIfAborted();
     if (nextCtx) {
       if (nextCtx.context) ctx.context = safeObjectMerge(ctx.context, nextCtx.context);
       for (const key of Object.keys(nextCtx)) if (key === "response") setResponse(nextCtx.response);
       else if (key !== "context") ctx[key] = nextCtx[key];
     }
     index++;
-    const middleware = middlewares[index];
+    const isTerminal = index === middlewares.length;
+    const middleware = index < middlewares.length ? middlewares[index] : isTerminal ? terminal : void 0;
+    const middlewareNext = isTerminal && terminalNext ? terminalNext : next;
     if (!middleware) return ctx;
     let result;
     try {
       const pending = middleware({
         ...ctx,
-        next
+        next: middlewareNext
       });
-      if (pending === nextPromise) {
+      if (nextPromise && pending === nextPromise) {
         nextPromise = void 0;
-        result = await pending;
-        if (isSignalAborted(signal)) {
-          disposeAbandonedResult(result);
-          throw signal.reason;
-        }
-      } else result = await waitForRequest(pending, signal, disposeAbandonedResult);
+        await pending;
+        if (signal.aborted) throw signal.reason;
+        return ctx;
+      } else if (!isPromise(pending)) {
+        result = pending;
+        signal.throwIfAborted();
+      } else result = await waitForReason(pending, signal, disposeAbandonedResult, disposeAbandonedResult);
     } catch (err) {
-      if (isSignalAborted(signal)) throw signal.reason;
-      if (isSpecialResponse(err)) {
+      reconcileCtxResponse();
+      if (signal.aborted) {
+        if (result !== void 0) disposeAbandonedResult(result);
+        if (err !== signal.reason) disposeAbandonedResult(err);
+        throw signal.reason;
+      }
+      if (err instanceof Response) {
         setResponse(err);
         return ctx;
       }
       throw err;
     }
-    const normalized = handleCtxResult(result);
-    if (normalized) {
-      if (normalized.response !== void 0) setResponse(normalized.response);
-      if (normalized.context) ctx.context = safeObjectMerge(ctx.context, normalized.context);
+    if (isTerminal && terminalNext && !result) throwRouteHandlerError();
+    reconcileCtxResponse();
+    if (result && result !== ctx) {
+      const response = getResponseFromResult(result);
+      if (response !== void 0 && response !== ctx.response) setResponse(response);
+      if (response !== result && result.context && result.context !== ctx.context) ctx.context = safeObjectMerge(ctx.context, result.context);
     }
     return ctx;
   }
   try {
     await runNext();
-    const response = await waitForRequest(getFinalResponse(), signal, disposeAbandonedResult);
-    if (signal.aborted) {
-      disposeAbandonedResult(response);
-      throw signal.reason;
-    }
-    return {
-      ctx,
-      response
-    };
+    const response = ctx.response;
+    if (!response) throwRouteHandlerError();
+    reconcileCtxResponse();
+    if (signal.aborted) throw signal.reason;
+    settled = true;
+    return responseOwnership ? getOwnedResponse(responseOwnership) : response;
   } catch (err) {
-    const disposal = disposeStreamResponse(signal.aborted ? signal.reason : err);
-    if (signal.aborted) disposal.catch(console.error);
-    else await disposal;
+    settled = true;
+    if (responseOwnership) disposeResponseOwnership(responseOwnership, signal.aborted ? signal.reason : err);
     throw err;
   }
 }
-function handlerToMiddleware(handler, mayDefer = false) {
-  if (mayDefer) return handler;
-  return async (ctx) => {
-    const response = await handler({
-      ...ctx,
-      next: throwIfMayNotDefer
-    });
-    if (!response) throwRouteHandlerError();
-    return response;
-  };
-}
 function createStartHandler(cbOrOptions) {
   const handlerOptions = typeof cbOrOptions === "function" ? {} : cbOrOptions;
   const cb = typeof cbOrOptions === "function" ? cbOrOptions : cbOrOptions.handler;
@@ -5153,17 +5869,25 @@ function createStartHandler(cbOrOptions) {
   const resolveManifestForRequest = finalManifestResolver.resolveCached;
   finalManifestResolver.warmup({ getBaseManifest: () => getBaseManifest(void 0) });
   const startRequestResolver = async (request, requestOpts) => {
-    let router = null;
+    const signal = request.signal;
+    let router;
+    let routerPromise;
     let responseOwnsCleanup = false;
     try {
-      request.signal.throwIfAborted();
+      signal.throwIfAborted();
       const { url, handledProtocolRelativeURL } = getNormalizedURL(request.url);
       const href = url.pathname + url.search + url.hash;
-      const origin = getOrigin(request);
+      const origin = url.origin;
       if (handledProtocolRelativeURL) return Response.redirect(url, 308);
-      const entries = await waitForRequest(getEntries(), request.signal);
-      const hasStartInstance = !!entries.startEntry.startInstance;
-      const startOptions = await waitForRequest(entries.startEntry.startInstance?.getOptions(), request.signal) || {};
+      const entries = await waitForReason(getEntries(), signal);
+      const isServerFnRequest = !!SERVER_FN_BASE && url.pathname.startsWith(SERVER_FN_BASE);
+      const startInstance = entries.startEntry.startInstance;
+      let startOptions;
+      if (startInstance) {
+        const pendingStartOptions = startInstance.getOptions();
+        startOptions = isPromise(pendingStartOptions) ? await waitForReason(pendingStartOptions, signal) : pendingStartOptions;
+        signal.throwIfAborted();
+      } else startOptions = {};
       const { hasPluginAdapters, pluginSerializationAdapters } = entries.pluginAdapters;
       const serializationAdapters = [
         ...startOptions.serializationAdapters || [],
@@ -5172,165 +5896,179 @@ function createStartHandler(cbOrOptions) {
       ];
       const requestStartOptions = {
         ...startOptions,
-        requestMiddleware: hasStartInstance ? startOptions.requestMiddleware : [defaultCsrfMiddleware],
+        requestMiddleware: startInstance ? startOptions.requestMiddleware : isServerFnRequest ? [defaultCsrfMiddleware] : void 0,
         serializationAdapters
       };
       const flattenedRequestMiddlewares = requestStartOptions.requestMiddleware ? flattenMiddlewares(requestStartOptions.requestMiddleware) : [];
       const executedRequestMiddlewares = new Set(flattenedRequestMiddlewares);
-      const getRouter = async () => {
-        if (router) return router;
-        router = await waitForRequest(entries.routerEntry.getRouter(), request.signal);
-        let isShell = IS_SHELL_ENV;
-        if (IS_PRERENDERING && !isShell) isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
-        const history = createMemoryHistory({ initialEntries: [href] });
-        router.update({
-          history,
-          isShell,
-          isPrerendering: IS_PRERENDERING,
-          origin: router.options.origin ?? origin,
-          defaultSsr: requestStartOptions.defaultSsr,
-          serializationAdapters: [...requestStartOptions.serializationAdapters, ...router.options.serializationAdapters || []],
-          basepath: ROUTER_BASEPATH
-        });
-        return router;
+      const getRouter = () => {
+        routerPromise ??= (async () => {
+          signal.throwIfAborted();
+          const requestRouter = await waitForReason(entries.routerEntry.getRouter(), signal);
+          let isShell = IS_SHELL_ENV;
+          if (IS_PRERENDERING && !isShell) isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
+          const history = createServerHistory(href);
+          requestRouter.update({
+            history,
+            isShell,
+            isPrerendering: IS_PRERENDERING,
+            origin: requestRouter.options.origin ?? origin,
+            defaultSsr: requestStartOptions.defaultSsr,
+            serializationAdapters: [...requestStartOptions.serializationAdapters, ...requestRouter.options.serializationAdapters || []],
+            basepath: ROUTER_BASEPATH
+          });
+          router = requestRouter;
+          return requestRouter;
+        })();
+        return routerPromise;
       };
-      if (SERVER_FN_BASE && url.pathname.startsWith(SERVER_FN_BASE)) {
+      const handlerType = isServerFnRequest ? "serverFn" : "router";
+      const startContext = {
+        getRouter,
+        startOptions: requestStartOptions,
+        request,
+        executedRequestMiddlewares,
+        handlerType
+      };
+      let terminal;
+      if (isServerFnRequest) {
         const serverFnId = url.pathname.slice(SERVER_FN_BASE.length).split("/")[0];
         if (!serverFnId) throw new Error("Invalid server action param for serverFnId");
-        const serverFnHandler = async ({ context }) => {
-          return runWithStartContext({
-            getRouter,
-            startOptions: requestStartOptions,
-            contextAfterGlobalMiddlewares: context,
+        terminal = ({ context }) => runWithStartContext({
+          ...startContext,
+          contextAfterGlobalMiddlewares: context
+        }, () => handleServerAction({
+          request,
+          context: requestOpts?.context,
+          serverFnId
+        }));
+      } else {
+        const executeRouter = async (serverContext, matchedRoutes) => {
+          if (!/(^|,)\s*(\*\/\*|text\/html)/.test(request.headers.get("Accept") || "*/*")) return normalizeSsrResponse(Response.json({ error: "Only HTML requests are supported here" }, { status: 406 }));
+          const manifest2 = await waitForReason(resolveManifestForRequest({
             request,
-            executedRequestMiddlewares,
-            handlerType: "serverFn"
-          }, () => handleServerAction({
+            requestInlineCss: requestOpts?.inlineCss,
+            getBaseManifest: () => getBaseManifest(matchedRoutes)
+          }), signal);
+          const earlyHints = createEarlyHintsForRequest({
+            onEarlyHints: requestOpts?.onEarlyHints,
+            responseLinkHeader: requestOpts?.responseLinkHeader
+          });
+          earlyHints?.collectStatic({
+            manifest: manifest2,
+            matchedRoutes
+          });
+          const routerInstance = await getRouter();
+          attachRouterServerSsrUtils({
+            router: routerInstance,
+            manifest: manifest2,
+            getRequestAssets: () => getStartContext({ throwIfNotFound: false })?.requestAssets
+          });
+          routerInstance.options.additionalContext = { serverContext };
+          await routerInstance.load({ _signal: signal });
+          signal.throwIfAborted();
+          if (routerInstance._serverResult?.type === "redirect") return normalizeSsrResponse(routerInstance._serverResult.redirect);
+          earlyHints?.collectDynamic(_getRenderedMatches(routerInstance.stores.matches.get()));
+          const ctx = getStartContext({ throwIfNotFound: false });
+          await routerInstance.serverSsr.dehydrate({
+            requestAssets: ctx?.requestAssets,
+            signal
+          });
+          signal.throwIfAborted();
+          const responseHeaders = getStartResponseHeaders({ router: routerInstance });
+          earlyHints?.appendResponseHeaders(responseHeaders);
+          signal.throwIfAborted();
+          const disposeLate = createLateResponseDisposer(signal);
+          return normalizeSsrResponse(await waitForReason(cb({
             request,
-            context: requestOpts?.context,
-            serverFnId
-          }));
+            router: routerInstance,
+            responseHeaders
+          }), signal, disposeLate, disposeLate));
         };
-        const { response: middlewareResponse2 } = await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), serverFnHandler], {
-          request,
-          pathname: url.pathname,
-          handlerType: "serverFn",
-          context: createNullProtoObject(requestOpts?.context)
-        }, request.signal);
-        const result = await handleRedirectResponse(middlewareResponse2, request, getRouter, request.signal);
-        bindSsrResponseToRequest(router ?? void 0, result, request.signal);
-        request.signal.throwIfAborted();
-        responseOwnsCleanup = result.serverSsrCleanup === "stream";
-        return result.response;
-      }
-      const executeRouter = async (serverContext, matchedRoutes) => {
-        const acceptParts = (request.headers.get("Accept") || "*/*").split(",");
-        if (!["*/*", "text/html"].some((mimeType) => acceptParts.some((part) => part.trim().startsWith(mimeType)))) return normalizeSsrResponse(Response.json({ error: "Only HTML requests are supported here" }, { status: 500 }));
-        const manifest2 = await waitForRequest(resolveManifestForRequest({
-          request,
-          requestInlineCss: requestOpts?.inlineCss,
-          getBaseManifest: () => getBaseManifest(matchedRoutes)
-        }), request.signal);
-        const earlyHints = createEarlyHintsForRequest({
-          onEarlyHints: requestOpts?.onEarlyHints,
-          responseLinkHeader: requestOpts?.responseLinkHeader
-        });
-        earlyHints?.collectStatic({
-          manifest: manifest2,
-          matchedRoutes
-        });
-        const routerInstance = await getRouter();
-        attachRouterServerSsrUtils({
-          router: routerInstance,
-          manifest: manifest2,
-          getRequestAssets: () => getStartContext({ throwIfNotFound: false })?.requestAssets
-        });
-        routerInstance.options.additionalContext = { serverContext };
-        await routerInstance.load({ _signal: request.signal });
-        request.signal.throwIfAborted();
-        if (routerInstance._serverResult?.type === "redirect") return normalizeSsrResponse(routerInstance._serverResult.redirect);
-        earlyHints?.collectDynamic(_getRenderedMatches(routerInstance.stores.matches.get()));
-        const ctx = getStartContext({ throwIfNotFound: false });
-        await waitForRequest(routerInstance.serverSsr.dehydrate({ requestAssets: ctx?.requestAssets }), request.signal);
-        request.signal.throwIfAborted();
-        const responseHeaders = getStartResponseHeaders({ router: routerInstance });
-        earlyHints?.appendResponseHeaders(responseHeaders);
-        request.signal.throwIfAborted();
-        return normalizeSsrResponse(await waitForRequest(cb({
-          request,
-          router: routerInstance,
-          responseHeaders
-        }), request.signal, (late) => disposeLateResponse(late, request.signal)));
-      };
-      const requestHandlerMiddleware = async ({ context }) => {
-        return runWithStartContext({
+        terminal = ({ context }) => runWithStartContext({
+          ...startContext,
+          contextAfterGlobalMiddlewares: context
+        }, () => handleServerRoutes({
           getRouter,
-          startOptions: requestStartOptions,
-          contextAfterGlobalMiddlewares: context,
           request,
-          executedRequestMiddlewares,
-          handlerType: "router"
-        }, async () => {
-          try {
-            return await handleServerRoutes({
-              getRouter,
-              request,
-              url,
-              executeRouter,
-              context,
-              executedRequestMiddlewares
-            });
-          } catch (err) {
-            if (err instanceof Response) return err;
-            throw err;
-          }
-        });
-      };
-      const { response: middlewareResponse } = await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), requestHandlerMiddleware], {
+          url,
+          executeRouter,
+          context,
+          executedRequestMiddlewares
+        }));
+      }
+      const middlewareResponse = await executeMiddleware(flattenedRequestMiddlewares.map((d) => d.options.server), terminal, {
         request,
         pathname: url.pathname,
-        handlerType: "router",
+        handlerType,
         context: createNullProtoObject(requestOpts?.context)
-      }, request.signal);
-      const response = await handleRedirectResponse(middlewareResponse, request, getRouter, request.signal);
-      bindSsrResponseToRequest(router ?? void 0, response, request.signal);
-      request.signal.throwIfAborted();
-      responseOwnsCleanup = response.serverSsrCleanup === "stream";
-      return response.response;
+      }, signal);
+      let result;
+      try {
+        result = await handleRedirectResponse(middlewareResponse, getRouter, signal, isServerFnRequest && request.headers.get("x-tsr-serverFn") === "true");
+        if (request.method === "HEAD") result = stripSsrResponseBody(result, "HEAD body stripped");
+      } catch (error) {
+        disposeResponseResult(middlewareResponse, signal.aborted ? signal.reason : error);
+        throw error;
+      }
+      bindSsrResponseToRequest(router, result, signal);
+      signal.throwIfAborted();
+      responseOwnsCleanup = result.serverSsrCleanup === "stream";
+      return result.response;
     } finally {
       if (router?.serverSsr && !responseOwnsCleanup) router.serverSsr.cleanup();
-      router = null;
     }
   };
   return requestHandler(startRequestResolver);
 }
-async function handleRedirectResponse(response, request, getRouter, signal) {
+var relativeRedirectProtocols = /* @__PURE__ */ new Set();
+async function handleRedirectResponse(response, getRouter, signal, serializeRedirect) {
   signal.throwIfAborted();
   const ssrResponse = normalizeSsrResponse(response);
-  if (!isRedirect(ssrResponse.response)) return ssrResponse;
-  if (isResolvedRedirect(ssrResponse.response)) {
-    if (request.headers.get("x-tsr-serverFn") === "true") return waitForRequest(replaceSsrResponse(ssrResponse, Response.json({
-      ...ssrResponse.response.options,
-      isSerializedRedirect: true
-    }, { headers: ssrResponse.response.headers }), "redirect response replaced"), signal);
-    return ssrResponse;
-  }
-  const opts = ssrResponse.response.options;
-  if (opts.to && typeof opts.to === "string" && !opts.to.startsWith("/")) throw new Error(`Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(opts)}`);
-  if ([
+  const redirect = ssrResponse.response;
+  if (!isRedirect(redirect)) return ssrResponse;
+  const opts = redirect.options;
+  const href = redirect.headers.get("Location") || opts.href;
+  if (!href && opts.to && typeof opts.to === "string" && !opts.to.startsWith("/")) throw new Error(`Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(opts)}`);
+  if (!href && [
     "params",
     "search",
     "hash"
   ].some((d) => typeof opts[d] === "function")) throw new Error(`Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(opts).filter((d) => typeof opts[d] === "function").map((d) => `"${d}"`).join(", ")}`);
   signal.throwIfAborted();
-  const router = await waitForRequest(getRouter(), signal);
-  signal.throwIfAborted();
-  const redirect = router.resolveRedirect(ssrResponse.response);
-  if (request.headers.get("x-tsr-serverFn") === "true") return waitForRequest(replaceSsrResponse(ssrResponse, Response.json({
-    ...ssrResponse.response.options,
-    isSerializedRedirect: true
-  }, { headers: ssrResponse.response.headers }), "redirect response replaced"), signal);
-  return waitForRequest(replaceSsrResponse(ssrResponse, redirect, "redirect response replaced"), signal);
+  if (href && !isDangerousProtocol(href, relativeRedirectProtocols)) {
+    opts.href = href;
+    redirect.headers.set("Location", href);
+  } else {
+    const router = await getRouter();
+    signal.throwIfAborted();
+    router.resolveRedirect(redirect);
+  }
+  if (serializeRedirect) {
+    const redirectOptions = { ...opts };
+    delete redirectOptions.headers;
+    const responseHeaders = new Headers(redirect.headers);
+    responseHeaders.set("content-type", "application/json");
+    return replaceSsrResponse(ssrResponse, Response.json({
+      ...redirectOptions,
+      isSerializedRedirect: true
+    }, { headers: responseHeaders }), "redirect response replaced");
+  }
+  return ssrResponse;
+}
+function withParsedParams(handler, matchedRoutes) {
+  if (!matchedRoutes.some((route) => route.options.params?.parse ?? route.options.parseParams)) return handler;
+  return (ctx) => {
+    const params = Object.assign(/* @__PURE__ */ Object.create(null), ctx.params);
+    for (const route of matchedRoutes) {
+      const parse = route.options.params?.parse ?? route.options.parseParams;
+      if (parse) Object.assign(params, parse(params));
+    }
+    return handler({
+      ...ctx,
+      params
+    });
+  };
 }
 async function handleServerRoutes({ getRouter, request, url, executeRouter, context, executedRequestMiddlewares }) {
   const router = await getRouter();
@@ -5338,6 +6076,8 @@ async function handleServerRoutes({ getRouter, request, url, executeRouter, cont
   const [matchedRoutes, rawParams, foundRoute] = router.getMatchedRoutes(pathname);
   const isExactMatch = foundRoute && rawParams["**"] === void 0;
   const routeMiddlewares = [];
+  let terminalHandler = (ctx) => executeRouter(ctx.context, matchedRoutes);
+  let terminalNext;
   for (const route of matchedRoutes) {
     const serverMiddleware = route.options.server?.middleware;
     if (serverMiddleware) {
@@ -5346,37 +6086,35 @@ async function handleServerRoutes({ getRouter, request, url, executeRouter, cont
     }
   }
   const server = foundRoute?.options.server;
-  let isHeadFallback = false;
   if (server?.handlers && isExactMatch) {
     const handlers = typeof server.handlers === "function" ? server.handlers({ createHandlers: (d) => d }) : server.handlers;
     const requestMethod = request.method.toUpperCase();
     const handler = requestMethod === "HEAD" ? handlers["HEAD"] ?? handlers["GET"] ?? handlers["ANY"] : handlers[requestMethod] ?? handlers["ANY"];
-    isHeadFallback = requestMethod === "HEAD" && handler !== void 0 && !handlers["HEAD"];
     if (handler) {
       const mayDefer = !!foundRoute.options.component;
-      if (typeof handler === "function") routeMiddlewares.push(handlerToMiddleware(handler, mayDefer));
-      else {
+      if (typeof handler !== "function") {
         if (handler.middleware?.length) {
           const handlerMiddlewares = flattenMiddlewares(handler.middleware);
           for (const m of handlerMiddlewares) routeMiddlewares.push(m.options.server);
         }
-        if (handler.handler) routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
+      }
+      const routeHandler = typeof handler === "function" ? handler : handler.handler;
+      if (routeHandler) {
+        const parsedHandler = withParsedParams(routeHandler, matchedRoutes);
+        if (!mayDefer) {
+          terminalHandler = parsedHandler;
+          terminalNext = throwIfMayNotDefer;
+        } else routeMiddlewares.push(parsedHandler);
       }
     }
   }
-  routeMiddlewares.push(((ctx2) => executeRouter(ctx2.context, matchedRoutes)));
-  const { ctx, response } = await executeMiddleware(routeMiddlewares, {
+  return normalizeSsrResponse(await executeMiddleware(routeMiddlewares, terminalHandler, {
     request,
     context,
     params: rawParams,
     pathname,
     handlerType: "router"
-  }, request.signal);
-  if (isHeadFallback) {
-    if (!ctx.response) throwRouteHandlerError();
-    return waitForRequest(stripSsrResponseBody(await handleRedirectResponse(response, request, getRouter, request.signal), "HEAD body stripped"), request.signal);
-  }
-  return normalizeSsrResponse(response);
+  }, request.signal, terminalNext));
 }
 var fetch$1 = createStartHandler(defaultStreamHandler);
 function createServerEntry(entry) {