@phosart/devtool 0.2.68 → 0.3.0

package/build/server/index.js

@@ -1,8 +1,7 @@
-import { w as with_request_store, D as DevalueError, i as is_primitive, g as get_type, a as is_plain_object, e as enumerable_symbols, s as stringify_key, b as stringify_string, v as valid_array_indices, r as root, d as decode_pathname, B as BROWSER, n as normalize_path, c as disable_search, u as uneval, f as resolve, m as make_trackable } from './chunks/url-DAcOnjX0.js';
-import { H as HttpError, j as json, t as text, S as SvelteKitError, R as Redirect, e as error, A as ActionFailure } from './chunks/index-CoD1IJuy.js';
-import { b as base, a as app_dir, f as find_route, c as assets, r as relative, o as override, d as reset } from './chunks/routing-DnQyokYQ.js';
-import { t as text_decoder, b as base64_decode, v as validate_layout_server_exports, a as validate_layout_exports, c as validate_page_server_exports, d as validate_page_exports, e as text_encoder, f as base64_encode, g as get_relative_path } from './chunks/exports-7ECo9oy7.js';
-import { w as writable, r as readable } from './chunks/index-DeXr9LUC.js';
+import { H as HttpError, j as json, S as SvelteKitError, t as text, R as Redirect, i as isRedirect, e as error, A as ActionFailure } from './chunks/index-lhTMmBNn.js';
+import { w as with_request_store, u as uneval, U as UNDEFINED, N as NAN, P as POSITIVE_INFINITY, a as NEGATIVE_INFINITY, b as NEGATIVE_ZERO, S as SPARSE, i as is_valid_array_len, M as MAX_ARRAY_INDEX, c as is_valid_array_index, H as HOLE, D as DevalueError, d as is_primitive, g as get_type, e as is_plain_object, f as enumerable_symbols, s as stringify_key, h as stringify_string, v as valid_array_indices, r as root, j as decode_pathname, k as DEV, n as normalize_path, l as disable_search, m as resolve, o as make_trackable } from './chunks/root-C9Hma45-.js';
+import { b as base64_decode, v as validate_layout_server_exports, a as validate_layout_exports, c as validate_page_server_exports, d as validate_page_exports, t as text_encoder, w as writable, r as readable, e as base64_encode, g as get_relative_path } from './chunks/exports-C9KHKwPe.js';
+import { b as base, a as app_dir, f as find_route, c as assets, r as relative, o as override, d as reset } from './chunks/routing-DYQTvdBm.js';
 
 /**
  * @template {{ tracing: { enabled: boolean, root: import('@opentelemetry/api').Span, current: import('@opentelemetry/api').Span } }} T
@@ -20,87 +19,242 @@ function merge_tracing(event_like, current) {
 	};
 }
 
+function noop() {
+}
+function once(fn) {
+  let done = false;
+  let result;
+  return () => {
+    if (done) return result;
+    done = true;
+    return result = fn();
+  };
+}
 const SVELTE_KIT_ASSETS = "/_svelte_kit_assets";
 const ENDPOINT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
-const MUTATIVE_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
 const PAGE_METHODS = ["GET", "POST", "HEAD"];
-function encode64(arraybuffer) {
-  const dv = new DataView(arraybuffer);
-  let binaryString = "";
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    binaryString += String.fromCharCode(dv.getUint8(i));
-  }
-  return binaryToAscii(binaryString);
-}
-function decode64(string) {
-  const binaryString = asciiToBinary(string);
-  const arraybuffer = new ArrayBuffer(binaryString.length);
-  const dv = new DataView(arraybuffer);
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    dv.setUint8(i, binaryString.charCodeAt(i));
-  }
-  return arraybuffer;
-}
-const KEY_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function asciiToBinary(data) {
-  if (data.length % 4 === 0) {
-    data = data.replace(/==?$/, "");
-  }
-  let output = "";
-  let buffer = 0;
-  let accumulatedBits = 0;
-  for (let i = 0; i < data.length; i++) {
-    buffer <<= 6;
-    buffer |= KEY_STRING.indexOf(data[i]);
-    accumulatedBits += 6;
-    if (accumulatedBits === 24) {
-      output += String.fromCharCode((buffer & 16711680) >> 16);
-      output += String.fromCharCode((buffer & 65280) >> 8);
-      output += String.fromCharCode(buffer & 255);
-      buffer = accumulatedBits = 0;
-    }
-  }
-  if (accumulatedBits === 12) {
-    buffer >>= 4;
-    output += String.fromCharCode(buffer);
-  } else if (accumulatedBits === 18) {
-    buffer >>= 2;
-    output += String.fromCharCode((buffer & 65280) >> 8);
-    output += String.fromCharCode(buffer & 255);
-  }
-  return output;
-}
-function binaryToAscii(str) {
-  let out = "";
-  for (let i = 0; i < str.length; i += 3) {
-    const groupsOfSix = [void 0, void 0, void 0, void 0];
-    groupsOfSix[0] = str.charCodeAt(i) >> 2;
-    groupsOfSix[1] = (str.charCodeAt(i) & 3) << 4;
-    if (str.length > i + 1) {
-      groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
-      groupsOfSix[2] = (str.charCodeAt(i + 1) & 15) << 2;
-    }
-    if (str.length > i + 2) {
-      groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
-      groupsOfSix[3] = str.charCodeAt(i + 2) & 63;
-    }
-    for (let j = 0; j < groupsOfSix.length; j++) {
-      if (typeof groupsOfSix[j] === "undefined") {
-        out += "=";
+var defaultParseOptions = {
+  decodeValues: true,
+  map: false,
+  silent: false,
+  split: "auto"
+  // auto = split strings but not arrays
+};
+function isForbiddenKey(key) {
+  return typeof key !== "string" || key in {};
+}
+function createNullObj() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function isNonEmptyString(str) {
+  return typeof str === "string" && !!str.trim();
+}
+function parseString(setCookieValue, options) {
+  var parts = setCookieValue.split(";").filter(isNonEmptyString);
+  var nameValuePairStr = parts.shift();
+  var parsed = parseNameValuePair(nameValuePairStr);
+  var name = parsed.name;
+  var value = parsed.value;
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (isForbiddenKey(name)) {
+    return null;
+  }
+  try {
+    value = options.decodeValues ? decodeURIComponent(value) : value;
+  } catch (e) {
+    console.error(
+      "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
+      e
+    );
+  }
+  var cookie = createNullObj();
+  cookie.name = name;
+  cookie.value = value;
+  parts.forEach(function(part) {
+    var sides = part.split("=");
+    var key = sides.shift().trimLeft().toLowerCase();
+    if (isForbiddenKey(key)) {
+      return;
+    }
+    var value2 = sides.join("=");
+    if (key === "expires") {
+      cookie.expires = new Date(value2);
+    } else if (key === "max-age") {
+      var n = parseInt(value2, 10);
+      if (!Number.isNaN(n)) cookie.maxAge = n;
+    } else if (key === "secure") {
+      cookie.secure = true;
+    } else if (key === "httponly") {
+      cookie.httpOnly = true;
+    } else if (key === "samesite") {
+      cookie.sameSite = value2;
+    } else if (key === "partitioned") {
+      cookie.partitioned = true;
+    } else if (key) {
+      cookie[key] = value2;
+    }
+  });
+  return cookie;
+}
+function parseNameValuePair(nameValuePairStr) {
+  var name = "";
+  var value = "";
+  var nameValueArr = nameValuePairStr.split("=");
+  if (nameValueArr.length > 1) {
+    name = nameValueArr.shift();
+    value = nameValueArr.join("=");
+  } else {
+    value = nameValuePairStr;
+  }
+  return { name, value };
+}
+function parseSetCookie(input, options) {
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (!input) {
+    if (!options.map) {
+      return [];
+    } else {
+      return createNullObj();
+    }
+  }
+  if (input.headers) {
+    if (typeof input.headers.getSetCookie === "function") {
+      input = input.headers.getSetCookie();
+    } else if (input.headers["set-cookie"]) {
+      input = input.headers["set-cookie"];
+    } else {
+      var sch = input.headers[Object.keys(input.headers).find(function(key) {
+        return key.toLowerCase() === "set-cookie";
+      })];
+      if (!sch && input.headers.cookie && !options.silent) {
+        console.warn(
+          "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+        );
+      }
+      input = sch;
+    }
+  }
+  var split = options.split;
+  var isArray = Array.isArray(input);
+  if (split === "auto") {
+    split = !isArray;
+  }
+  if (!isArray) {
+    input = [input];
+  }
+  input = input.filter(isNonEmptyString);
+  if (split) {
+    input = input.map(splitCookiesString).flat();
+  }
+  if (!options.map) {
+    return input.map(function(str) {
+      return parseString(str, options);
+    }).filter(Boolean);
+  } else {
+    var cookies = createNullObj();
+    return input.reduce(function(cookies2, str) {
+      var cookie = parseString(str, options);
+      if (cookie && !isForbiddenKey(cookie.name)) {
+        cookies2[cookie.name] = cookie;
+      }
+      return cookies2;
+    }, cookies);
+  }
+}
+function splitCookiesString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString;
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  var cookiesStrings = [];
+  var pos = 0;
+  var start;
+  var ch;
+  var lastComma;
+  var nextStart;
+  var cookiesSeparatorFound;
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
       } else {
-        out += KEY_STRING[groupsOfSix[j]];
+        pos += 1;
       }
     }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+parseSetCookie.parseSetCookie = parseSetCookie;
+parseSetCookie.parse = parseSetCookie;
+parseSetCookie.parseString = parseString;
+parseSetCookie.splitCookiesString = splitCookiesString;
+function encode_native(array_buffer) {
+  return new Uint8Array(array_buffer).toBase64();
+}
+function decode_native(base64) {
+  return Uint8Array.fromBase64(base64).buffer;
+}
+function encode_buffer(array_buffer) {
+  return Buffer.from(array_buffer).toString("base64");
+}
+function decode_buffer(base64) {
+  return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+function encode_legacy(array_buffer) {
+  const array = new Uint8Array(array_buffer);
+  let binary = "";
+  const chunk_size = 32768;
+  for (let i = 0; i < array.length; i += chunk_size) {
+    const chunk = array.subarray(i, i + chunk_size);
+    binary += String.fromCharCode.apply(null, chunk);
+  }
+  return btoa(binary);
+}
+function decode_legacy(base64) {
+  const binary_string = atob(base64);
+  const len = binary_string.length;
+  const array = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = binary_string.charCodeAt(i);
   }
-  return out;
+  return array.buffer;
 }
-const UNDEFINED = -1;
-const HOLE = -2;
-const NAN = -3;
-const POSITIVE_INFINITY = -4;
-const NEGATIVE_INFINITY = -5;
-const NEGATIVE_ZERO = -6;
-const SPARSE = -7;
+const native = typeof Uint8Array.fromBase64 === "function";
+const buffer = typeof process === "object" && process.versions?.node !== void 0;
+const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
 function parse(serialized, revivers) {
   return unflatten(JSON.parse(serialized), revivers);
 }
@@ -167,13 +321,14 @@ function unflatten(parsed, revivers) {
           case "RegExp":
             hydrated[index] = new RegExp(value[1], value[2]);
             break;
-          case "Object":
-            const object = Object(value[1]);
-            if (Object.hasOwn(object, "__proto__")) {
-              throw new Error("Cannot parse an object with a `__proto__` property");
+          case "Object": {
+            const wrapped_index = value[1];
+            if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") {
+              throw new Error("Invalid input");
             }
-            hydrated[index] = object;
+            hydrated[index] = Object(hydrate(wrapped_index));
             break;
+          }
           case "BigInt":
             hydrated[index] = BigInt(value[1]);
             break;
@@ -192,19 +347,20 @@ function unflatten(parsed, revivers) {
           case "Uint8ClampedArray":
           case "Int16Array":
           case "Uint16Array":
+          case "Float16Array":
           case "Int32Array":
           case "Uint32Array":
           case "Float32Array":
           case "Float64Array":
           case "BigInt64Array":
-          case "BigUint64Array": {
+          case "BigUint64Array":
+          case "DataView": {
             if (values[value[1]][0] !== "ArrayBuffer") {
               throw new Error("Invalid data");
             }
             const TypedArrayConstructor = globalThis[type];
-            const buffer = hydrate(value[1]);
-            const typedArray = new TypedArrayConstructor(buffer);
-            hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
+            const buffer2 = hydrate(value[1]);
+            hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer2, value[2], value[3]) : new TypedArrayConstructor(buffer2);
             break;
           }
           case "ArrayBuffer": {
@@ -243,18 +399,21 @@ function unflatten(parsed, revivers) {
         }
       } else if (value[0] === SPARSE) {
         const len = value[1];
-        if (!Number.isInteger(len) || len < 0) {
+        if (!is_valid_array_len(len)) {
           throw new Error("Invalid input");
         }
-        const array = new Array(len);
+        const array = [];
         hydrated[index] = array;
+        array[MAX_ARRAY_INDEX] = void 0;
+        delete array[MAX_ARRAY_INDEX];
         for (let i = 2; i < value.length; i += 2) {
           const idx = value[i];
-          if (!Number.isInteger(idx) || idx < 0 || idx >= len) {
+          if (!is_valid_array_index(idx) || idx >= len) {
             throw new Error("Invalid input");
           }
           array[idx] = hydrate(value[i + 1]);
         }
+        array.length = len;
       } else {
         const array = new Array(value.length);
         hydrated[index] = array;
@@ -280,6 +439,10 @@ function unflatten(parsed, revivers) {
   return hydrate(0);
 }
 function stringify$1(value, reducers) {
+  const stringified = run(false, value, reducers);
+  return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+function run(async, value, reducers) {
   const stringified = [];
   const indexes = /* @__PURE__ */ new Map();
   const custom = [];
@@ -290,14 +453,17 @@ function stringify$1(value, reducers) {
   }
   const keys = [];
   let p = 0;
-  function flatten(thing) {
+  function flatten(thing, index2) {
     if (thing === void 0) return UNDEFINED;
     if (Number.isNaN(thing)) return NAN;
     if (thing === Infinity) return POSITIVE_INFINITY;
     if (thing === -Infinity) return NEGATIVE_INFINITY;
     if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
-    if (indexes.has(thing)) return indexes.get(thing);
-    const index2 = p++;
+    if (indexes.has(thing)) return (
+      /** @type {number} */
+      indexes.get(thing)
+    );
+    index2 ??= p++;
     indexes.set(thing, index2);
     for (const { key, fn } of custom) {
       const value2 = fn(thing);
@@ -308,20 +474,29 @@ function stringify$1(value, reducers) {
     }
     if (typeof thing === "function") {
       throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+    } else if (typeof thing === "symbol") {
+      throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
     let str = "";
     if (is_primitive(thing)) {
       str = stringify_primitive(thing);
+    } else if (typeof thing.then === "function") {
+      {
+        throw new DevalueError(
+          `Cannot stringify a Promise or thenable — use stringifyAsync instead`,
+          keys,
+          thing,
+          value
+        );
+      }
     } else {
       const type = get_type(thing);
       switch (type) {
         case "Number":
         case "String":
         case "Boolean":
-          str = `["Object",${stringify_primitive(thing)}]`;
-          break;
         case "BigInt":
-          str = `["BigInt",${thing}]`;
+          str = `["Object",${flatten(thing.valueOf())}]`;
           break;
         case "Date":
           const valid = !isNaN(thing.getDate());
@@ -385,9 +560,7 @@ function stringify$1(value, reducers) {
         case "Map":
           str = '["Map"';
           for (const [key, value2] of thing) {
-            keys.push(
-              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
-            );
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
           }
@@ -398,19 +571,18 @@ function stringify$1(value, reducers) {
         case "Uint8ClampedArray":
         case "Int16Array":
         case "Uint16Array":
+        case "Float16Array":
         case "Int32Array":
         case "Uint32Array":
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
-        case "BigUint64Array": {
+        case "BigUint64Array":
+        case "DataView": {
           const typedArray = thing;
           str = '["' + type + '",' + flatten(typedArray.buffer);
-          const a = thing.byteOffset;
-          const b = a + thing.byteLength;
-          if (a > 0 || b !== typedArray.buffer.byteLength) {
-            const m = +/(\d+)/.exec(type)[1] / 8;
-            str += `,${a / m},${b / m}`;
+          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
+            str += `,${typedArray.byteOffset},${typedArray.length}`;
           }
           str += "]";
           break;
@@ -433,20 +605,10 @@ function stringify$1(value, reducers) {
           break;
         default:
           if (!is_plain_object(thing)) {
-            throw new DevalueError(
-              `Cannot stringify arbitrary non-POJOs`,
-              keys,
-              thing,
-              value
-            );
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
           if (enumerable_symbols(thing).length > 0) {
-            throw new DevalueError(
-              `Cannot stringify POJOs with symbolic keys`,
-              keys,
-              thing,
-              value
-            );
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
           if (Object.getPrototypeOf(thing) === null) {
             str = '["null"';
@@ -491,17 +653,17 @@ function stringify$1(value, reducers) {
   }
   const index = flatten(value);
   if (index < 0) return `${index}`;
-  return `[${stringified.join(",")}]`;
+  return stringified;
 }
 function stringify_primitive(thing) {
   const type = typeof thing;
   if (type === "string") return stringify_string(thing);
-  if (thing instanceof String) return stringify_string(thing.toString());
   if (thing === void 0) return UNDEFINED.toString();
   if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
   if (type === "bigint") return `["BigInt","${thing}"]`;
   return String(thing);
 }
+const decoder = new TextDecoder();
 function set_nested_value(object, path_string, value) {
   if (path_string.startsWith("n:")) {
     path_string = path_string.slice(2);
@@ -549,10 +711,6 @@ async function deserialize_binary_form(request) {
   if (!request.body) {
     throw deserialize_error("no body");
   }
-  const content_length = parseInt(request.headers.get("content-length") ?? "");
-  if (Number.isNaN(content_length)) {
-    throw deserialize_error("invalid Content-Length header");
-  }
   const reader = request.body.getReader();
   const chunks = [];
   function get_chunk(index) {
@@ -593,13 +751,13 @@ async function deserialize_binary_form(request) {
       chunks2.push(chunk);
       cursor += chunk.byteLength;
     }
-    const buffer = new Uint8Array(length);
+    const buffer2 = new Uint8Array(length);
     cursor = 0;
     for (const chunk of chunks2) {
-      buffer.set(chunk, cursor);
+      buffer2.set(chunk, cursor);
       cursor += chunk.byteLength;
     }
-    return buffer;
+    return buffer2;
   }
   const header = await get_buffer(0, HEADER_BYTES);
   if (!header) throw deserialize_error("too short");
@@ -608,13 +766,7 @@ async function deserialize_binary_form(request) {
   }
   const header_view = new DataView(header.buffer, header.byteOffset, header.byteLength);
   const data_length = header_view.getUint32(1, true);
-  if (HEADER_BYTES + data_length > content_length) {
-    throw deserialize_error("data overflow");
-  }
   const file_offsets_length = header_view.getUint16(5, true);
-  if (HEADER_BYTES + data_length + file_offsets_length > content_length) {
-    throw deserialize_error("file offset table overflow");
-  }
   const data_buffer = await get_buffer(HEADER_BYTES, data_length);
   if (!data_buffer) throw deserialize_error("data too short");
   let file_offsets;
@@ -622,7 +774,7 @@ async function deserialize_binary_form(request) {
   if (file_offsets_length > 0) {
     const file_offsets_buffer = await get_buffer(HEADER_BYTES + data_length, file_offsets_length);
     if (!file_offsets_buffer) throw deserialize_error("file offset table too short");
-    const parsed_offsets = JSON.parse(text_decoder.decode(file_offsets_buffer));
+    const parsed_offsets = JSON.parse(decoder.decode(file_offsets_buffer));
     if (!Array.isArray(parsed_offsets) || parsed_offsets.some((n) => typeof n !== "number" || !Number.isInteger(n) || n < 0)) {
       throw deserialize_error("invalid file offset table");
     }
@@ -631,7 +783,7 @@ async function deserialize_binary_form(request) {
     files_start_offset = HEADER_BYTES + data_length + file_offsets_length;
   }
   const file_spans = [];
-  const [data, meta] = parse(text_decoder.decode(data_buffer), {
+  const [data, meta] = parse(decoder.decode(data_buffer), {
     File: ([name, type, size, last_modified, index]) => {
       if (typeof name !== "string" || typeof type !== "string" || typeof size !== "number" || typeof last_modified !== "number" || typeof index !== "number") {
         throw deserialize_error("invalid file metadata");
@@ -642,9 +794,6 @@ async function deserialize_binary_form(request) {
       }
       file_offsets[index] = void 0;
       offset += files_start_offset;
-      if (offset + size > content_length) {
-        throw deserialize_error("file data overflow");
-      }
       file_spans.push({ offset, size });
       return new Proxy(new LazyFile(name, type, size, last_modified, get_chunk, offset), {
         getPrototypeOf() {
@@ -787,7 +936,7 @@ class LazyFile {
     });
   }
   async text() {
-    return text_decoder.decode(await this.arrayBuffer());
+    return decoder.decode(await this.arrayBuffer());
   }
 }
 const path_regex = /^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/;
@@ -810,8 +959,8 @@ function deep_set(object, keys, value) {
     const key = keys[i];
     check_prototype_pollution(key);
     const is_array = /^\d+$/.test(keys[i + 1]);
-    const exists = Object.hasOwn(current, key);
-    const inner = current[key];
+    const inner = Object.hasOwn(current, key) ? current[key] : void 0;
+    const exists = inner != null;
     if (exists && is_array !== Array.isArray(inner)) {
       throw new Error(`Invalid array key ${keys[i + 1]}`);
     }
@@ -859,6 +1008,13 @@ function negotiate(accept, types) {
   }
   return accepted;
 }
+function get_set_cookies(headers) {
+  if (typeof headers.getSetCookie === "function") {
+    return headers.getSetCookie();
+  }
+  const set_cookie = headers.get("set-cookie");
+  return set_cookie ? splitCookiesString(set_cookie) : [];
+}
 function is_content_type(request, ...types) {
   const type = request.headers.get("content-type")?.split(";", 1)[0].trim() ?? "";
   return types.includes(type.toLowerCase());
@@ -1029,24 +1185,88 @@ function get_node_type(node_id) {
   const dot_parts = filename.split(".");
   return dot_parts.slice(0, -1).join(".");
 }
+function create_replacer(transport) {
+  const replacer = (thing) => {
+    for (const key in transport) {
+      const encoded = transport[key].encode(thing);
+      if (encoded) {
+        return `app.decode('${key}', ${uneval(encoded, replacer)})`;
+      }
+    }
+  };
+  return replacer;
+}
 const INVALIDATED_PARAM = "x-sveltekit-invalidated";
 const TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
 function stringify(data, transport) {
   const encoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode]));
   return stringify$1(data, encoders);
 }
+const remote_object = "__skrao";
+const remote_map = "__skram";
+const remote_set = "__skras";
+function create_remote_arg_revivers(transport) {
+  const remote_fns_revivers = {
+    /** @type {(value: unknown) => unknown} */
+    [remote_object]: (value) => value,
+    /** @type {(value: unknown) => Map<unknown, unknown>} */
+    [remote_map]: (value) => {
+      if (!Array.isArray(value)) {
+        throw new Error("Invalid data for Map reviver");
+      }
+      const map = /* @__PURE__ */ new Map();
+      for (const item of value) {
+        if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || typeof item[1] !== "string") {
+          throw new Error("Invalid data for Map reviver");
+        }
+        const [key, val] = item;
+        map.set(parse$1(key), parse$1(val));
+      }
+      return map;
+    },
+    /** @type {(value: unknown) => Set<unknown>} */
+    [remote_set]: (value) => {
+      if (!Array.isArray(value)) {
+        throw new Error("Invalid data for Set reviver");
+      }
+      const set = /* @__PURE__ */ new Set();
+      for (const item of value) {
+        if (typeof item !== "string") {
+          throw new Error("Invalid data for Set reviver");
+        }
+        set.add(parse$1(item));
+      }
+      return set;
+    }
+  };
+  const user_revivers = Object.fromEntries(
+    Object.entries(transport).map(([k, v]) => [k, v.decode])
+  );
+  const all_revivers = { ...user_revivers, ...remote_fns_revivers };
+  const parse$1 = (data) => parse(data, all_revivers);
+  return all_revivers;
+}
 function parse_remote_arg(string, transport) {
   if (!string) return void 0;
-  const json_string = text_decoder.decode(
+  const json_string = new TextDecoder().decode(
     // no need to add back `=` characters, atob can handle it
     base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))
   );
-  const decoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.decode]));
-  return parse(json_string, decoders);
+  return parse(json_string, create_remote_arg_revivers(transport));
 }
 function create_remote_key(id, payload) {
   return id + "/" + payload;
 }
+function split_remote_key(key) {
+  const i = key.lastIndexOf("/");
+  if (i === -1) {
+    throw new Error(`Invalid remote key: ${key}`);
+  }
+  return {
+    id: key.slice(0, i),
+    payload: key.slice(i + 1)
+  };
+}
 
 let public_env = {};
 function set_private_env(environment) {
@@ -1074,8 +1294,9 @@ const options = {
   root,
   service_worker: false,
   service_worker_options: void 0,
+  server_error_boundaries: false,
   templates: {
-    app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<meta name="viewport" content="width=device-width, initial-scale=1" />\n		' + head + '\n	</head>\n	<body data-sveltekit-preload-data="hover">\n		<div style="display: contents">' + body + "</div>\n	</body>\n</html>\n",
+    app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en" data-theme="mint">\n	<head>\n		<meta charset="utf-8" />\n		<meta name="viewport" content="width=device-width, initial-scale=1" />\n		' + head + '\n	</head>\n	<body data-sveltekit-preload-data="hover">\n		<div style="display: contents">' + body + "</div>\n	</body>\n</html>\n",
     error: ({ status, message }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<title>' + message + `</title>
 
 		<style>
@@ -1147,7 +1368,7 @@ const options = {
 		<div class="error">
 			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n"
   },
-  version_hash: "h0d2xc"
+  version_hash: "y8gl79"
 };
 async function get_hooks() {
   let handle;
@@ -1179,6 +1400,7 @@ function with_resolvers() {
 }
 const NULL_BODY_STATUS = [101, 103, 204, 205, 304];
 const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
+const s = JSON.stringify;
 async function render_endpoint(event, event_state, mod, state) {
   const method = (
     /** @type {import('types').HttpMethod} */
@@ -1203,7 +1425,6 @@ async function render_endpoint(event, event_state, mod, state) {
     }
   }
   try {
-    event_state.allows_commands = true;
     const response = await with_request_store(
       { event, state: event_state },
       () => handler(
@@ -1365,7 +1586,7 @@ async function handle_action_json_request(event, event_state, options2, server)
   check_named_default_separate(actions);
   try {
     const data = await call_action(event, event_state, actions);
-    if (BROWSER) ;
+    if (DEV) ;
     if (data instanceof ActionFailure) {
       return action_json({
         type: "failure",
@@ -1450,7 +1671,7 @@ async function handle_action_request(event, event_state, server) {
   check_named_default_separate(actions);
   try {
     const data = await call_action(event, event_state, actions);
-    if (BROWSER) ;
+    if (DEV) ;
     if (data instanceof ActionFailure) {
       return {
         type: "failure",
@@ -1519,7 +1740,6 @@ async function call_action(event, event_state, actions) {
     },
     fn: async (current2) => {
       const traced_event = merge_tracing(event, current2);
-      event_state.allows_commands = true;
       const result = await with_request_store(
         { event: traced_event, state: event_state },
         () => action(traced_event)
@@ -1535,14 +1755,7 @@ async function call_action(event, event_state, actions) {
   });
 }
 function uneval_action_response(data, route_id, transport) {
-  const replacer = (thing) => {
-    for (const key2 in transport) {
-      const encoded = transport[key2].encode(thing);
-      if (encoded) {
-        return `app.decode('${key2}', ${uneval(encoded, replacer)})`;
-      }
-    }
-  };
+  const replacer = create_replacer(transport);
   return try_serialize(data, (value) => uneval(value, replacer), route_id);
 }
 function stringify_action_response(data, route_id, transport) {
@@ -1666,9 +1879,9 @@ function server_data_serializer(event, event_state, options2) {
           strings[i] = "null";
           return;
         }
-        const payload = { type: "data", data: node.data, uses: serialize_uses(node) };
-        if (node.slash) payload.slash = node.slash;
-        strings[i] = uneval(payload, get_replacer(i));
+        const payload2 = { type: "data", data: node.data, uses: serialize_uses(node) };
+        if (node.slash) payload2.slash = node.slash;
+        strings[i] = uneval(payload2, get_replacer(i));
       } catch (e) {
         e.path = e.path.slice(1);
         throw new Error(clarify_devalue_error(
@@ -1910,8 +2123,9 @@ async function load_data({
     },
     fn: async (current2) => {
       const traced_event = merge_tracing(event, current2);
+      const child_state = { ...event_state, is_in_universal_load: true };
       return await with_request_store(
-        { event: traced_event, state: event_state },
+        { event: traced_event, state: child_state },
         () => load.call(null, {
           url: event.url,
           params: event.params,
@@ -1919,8 +2133,7 @@ async function load_data({
           route: event.route,
           fetch: create_universal_fetch(event, state, fetched, csr, resolve_opts),
           setHeaders: event.setHeaders,
-          depends: () => {
-          },
+          depends: noop,
           parent,
           untrack: (fn) => fn(),
           tracing: traced_event.tracing
@@ -1963,7 +2176,7 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
     let teed_body;
     const proxy = new Proxy(response, {
       get(response2, key2, receiver) {
-        async function push_fetched(body2, is_b64) {
+        async function push_fetched(body, is_b64) {
           const status_number = Number(response2.status);
           if (isNaN(status_number)) {
             throw new Error(
@@ -1978,7 +2191,7 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
               input instanceof Request && cloned_body ? await stream_to_string(cloned_body) : init2?.body
             ),
             request_headers: cloned_headers,
-            response_body: body2,
+            response_body: body,
             response: response2,
             is_b64
           });
@@ -2020,26 +2233,26 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
           };
         }
         async function text2() {
-          const body2 = await response2.text();
-          if (body2 === "" && NULL_BODY_STATUS.includes(response2.status)) {
+          const body = await response2.text();
+          if (body === "" && NULL_BODY_STATUS.includes(response2.status)) {
             await push_fetched(void 0, false);
             return void 0;
           }
-          if (!body2 || typeof body2 === "string") {
-            await push_fetched(body2, false);
+          if (!body || typeof body === "string") {
+            await push_fetched(body, false);
           }
           if (dependency) {
-            dependency.body = body2;
+            dependency.body = body;
           }
-          return body2;
+          return body;
         }
         if (key2 === "text") {
           return text2;
         }
         if (key2 === "json") {
           return async () => {
-            const body2 = await text2();
-            return body2 ? JSON.parse(body2) : void 0;
+            const body = await text2();
+            return body ? JSON.parse(body) : void 0;
           };
         }
         const value = Reflect.get(response2, key2, response2);
@@ -2080,20 +2293,21 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
   };
   return (input, init2) => {
     const response = universal_fetch(input, init2);
-    response.catch(() => {
-    });
+    response.catch(noop);
     return response;
   };
 }
 async function stream_to_string(stream) {
   let result = "";
   const reader = stream.getReader();
+  const decoder = new TextDecoder();
   while (true) {
     const { done, value } = await reader.read();
     if (done) {
+      result += decoder.decode();
       break;
     }
-    result += text_decoder.decode(value);
+    result += decoder.decode(value, { stream: true });
   }
   return result;
 }
@@ -2132,13 +2346,13 @@ function serialize_data(fetched, filter, prerendering = false) {
     else if (key2 === "age") age = value;
     else if (key2 === "vary" && value.trim() === "*") varyAny = true;
   }
-  const payload = {
+  const payload2 = {
     status: fetched.response.status,
     statusText: fetched.response.statusText,
     headers: headers2,
     body: fetched.response_body
   };
-  const safe_payload = JSON.stringify(payload).replace(pattern, (match) => replacements[match]);
+  const safe_payload = JSON.stringify(payload2).replace(pattern, (match) => replacements[match]);
   const attrs = [
     'type="application/json"',
     "data-sveltekit-fetched",
@@ -2166,7 +2380,6 @@ function serialize_data(fetched, filter, prerendering = false) {
   }
   return `<script ${attrs.join(" ")}>${safe_payload}<\/script>`;
 }
-const s = JSON.stringify;
 function sha256(data) {
   if (!key[0]) precompute();
   const out = init.slice(0);
@@ -2564,9 +2777,9 @@ function create_server_routing_response(route, params, url, manifest) {
   });
   if (route) {
     const csr_route = generate_route_object(route, url, manifest);
-    const body2 = `${create_css_import(route, url, manifest)}
+    const body = `${create_css_import(route, url, manifest)}
 export const route = ${csr_route}; export const params = ${JSON.stringify(params)};`;
-    return { response: text(body2, { headers: headers2 }), body: body2 };
+    return { response: text(body, { headers: headers2 }), body };
   } else {
     return { response: text("", { headers: headers2 }), body: "" };
   }
@@ -2605,7 +2818,8 @@ async function render_response({
   event_state,
   resolve_opts,
   action_result,
-  data_serializer
+  data_serializer,
+  error_components
 }) {
   if (state.prerendering) {
     if (options2.csp.mode === "nonce") {
@@ -2658,6 +2872,12 @@ async function render_response({
       ),
       form: form_value
     };
+    if (error_components) {
+      if (error2) {
+        props.error = error2;
+      }
+      props.errors = error_components;
+    }
     let data2 = {};
     for (let i = 0; i < branch.length; i += 1) {
       data2 = { ...data2, ...branch[i].data };
@@ -2685,12 +2905,24 @@ async function render_response({
           }
         ]
       ]),
-      csp: csp.script_needs_nonce ? { nonce: csp.nonce } : { hash: csp.script_needs_hash }
+      csp: csp.script_needs_nonce ? { nonce: csp.nonce } : { hash: csp.script_needs_hash },
+      transformError: error_components ? (
+        /** @param {unknown} e */
+        (async (e) => {
+          if (isRedirect(e)) {
+            throw e;
+          }
+          const transformed2 = await handle_error_and_jsonify(event, event_state, options2, e);
+          props.page.error = props.error = error2 = transformed2;
+          props.page.status = status = get_status(e);
+          return transformed2;
+        })
+      ) : void 0
     };
     try {
-      if (BROWSER) ;
-      event_state.allows_commands = false;
-      rendered = await with_request_store({ event, state: event_state }, async () => {
+      if (DEV) ;
+      const state2 = { ...event_state, is_in_render: true };
+      rendered = await with_request_store({ event, state: state2 }, async () => {
         if (relative) override({ base: base$1, assets: assets$1 });
         const maybe_promise = options2.root.render(props, render_opts);
         const rendered2 = options2.async && "then" in maybe_promise ? (
@@ -2712,25 +2944,25 @@ async function render_response({
     } finally {
       reset();
     }
-    for (const { node } of branch) {
-      for (const url of node.imports) modulepreloads.add(url);
-      for (const url of node.stylesheets) stylesheets.add(url);
-      for (const url of node.fonts) fonts.add(url);
-      if (node.inline_styles && !client.inline) {
-        Object.entries(await node.inline_styles()).forEach(([filename, css]) => {
-          if (typeof css === "string") {
-            inline_styles.set(filename, css);
-            return;
-          }
-          inline_styles.set(filename, css(`${assets$1}/${app_dir}/immutable/assets`, assets$1));
-        });
-      }
-    }
   } else {
     rendered = { head: "", html: "", css: { code: "", map: null }, hashes: { script: [] } };
   }
+  for (const { node } of branch) {
+    for (const url of node.imports) modulepreloads.add(url);
+    for (const url of node.stylesheets) stylesheets.add(url);
+    for (const url of node.fonts) fonts.add(url);
+    if (node.inline_styles && !client.inline) {
+      Object.entries(await node.inline_styles()).forEach(([filename, css]) => {
+        if (typeof css === "string") {
+          inline_styles.set(filename, css);
+          return;
+        }
+        inline_styles.set(filename, css(`${assets$1}/${app_dir}/immutable/assets`, assets$1));
+      });
+    }
+  }
   const head = new Head(rendered.head, !!state.prerendering);
-  let body2 = rendered.html;
+  let body = rendered.html;
   const prefixed = (path) => {
     if (path.startsWith("/")) {
       return base + path;
@@ -2769,7 +3001,7 @@ async function render_response({
   const global = get_global_name(options2);
   const { data, chunks } = data_serializer.get_data(csp);
   if (page_config.ssr && page_config.csr) {
-    body2 += `
+    body += `
 			${fetched.map(
       (item) => serialize_data(item, resolve_opts.filterSerializedResponseHeaders, !!state.prerendering)
     ).join("\n			")}`;
@@ -2885,28 +3117,60 @@ ${indent}	${hydrate.join(`,
 ${indent}	`)}
 ${indent}}`);
     }
-    const { remote_data: remote_cache } = event_state;
-    let serialized_remote_data = "";
-    if (remote_cache) {
-      const remote = {};
-      for (const [info, cache] of remote_cache) {
-        if (!info.id) continue;
+    const { remote } = event_state;
+    let serialized_query_data = "";
+    let serialized_prerender_data = "";
+    if (remote.data) {
+      const query = {};
+      const prerender = {};
+      for (const [internals, cache] of remote.data) {
+        if (!internals.id) continue;
         for (const key2 in cache) {
-          remote[create_remote_key(info.id, key2)] = await cache[key2];
-        }
-      }
-      const replacer = (thing) => {
-        for (const key2 in options2.hooks.transport) {
-          const encoded = options2.hooks.transport[key2].encode(thing);
-          if (encoded) {
-            return `app.decode('${key2}', ${uneval(encoded, replacer)})`;
+          const entry = cache[key2];
+          if (!entry.serialize) continue;
+          const remote_key = create_remote_key(internals.id, key2);
+          const store = internals.type === "prerender" ? prerender : query;
+          if (event_state.remote.refreshes?.has(remote_key) || event_state.remote.reconnects?.has(remote_key)) {
+            store[remote_key] = await entry.data;
+          } else {
+            const result = await Promise.race([
+              Promise.resolve(entry.data).then(
+                (v) => (
+                  /** @type {const} */
+                  { settled: true, value: v }
+                ),
+                (e) => (
+                  /** @type {const} */
+                  { settled: true, error: e }
+                )
+              ),
+              new Promise((resolve2) => {
+                queueMicrotask(() => resolve2(
+                  /** @type {const} */
+                  { settled: false }
+                ));
+              })
+            ]);
+            if (result.settled) {
+              if ("error" in result) throw result.error;
+              store[remote_key] = result.value;
+            }
           }
         }
-      };
-      serialized_remote_data = `${global}.data = ${uneval(remote, replacer)};
+      }
+      const replacer = create_replacer(options2.hooks.transport);
+      if (Object.keys(query).length > 0) {
+        serialized_query_data = `${global}.query = ${uneval(query, replacer)};
+
+						`;
+      }
+      if (Object.keys(prerender).length > 0) {
+        serialized_prerender_data = `${global}.prerender = ${uneval(prerender, replacer)};
 
 						`;
+      }
     }
+    const serialized_remote_data = `${serialized_query_data}${serialized_prerender_data}`;
     const boot = client.inline ? `${client.inline.script}
 
 					${serialized_remote_data}${global}.app.start(${args.join(", ")});` : client.app ? `Promise.all([
@@ -2933,8 +3197,14 @@ ${indent}}`);
         opts = `, ${s(service_worker_options)}`;
       }
       blocks.push(`if ('serviceWorker' in navigator) {
+						const script_url = '${prefixed("service-worker.js")}';
+						const policy = globalThis?.window?.trustedTypes?.createPolicy(
+							'sveltekit-trusted-url',
+							{ createScriptURL(url) { return url; } }
+						);
+						const sanitised = policy?.createScriptURL(script_url) ?? script_url;
 						addEventListener('load', function () {
-							navigator.serviceWorker.register('${prefixed("service-worker.js")}'${opts});
+							navigator.serviceWorker.register(sanitised${opts});
 						});
 					}`);
     }
@@ -2944,7 +3214,7 @@ ${indent}}`);
 				}
 			`;
     csp.add_script(init_app);
-    body2 += `
+    body += `
 			<script${csp.script_needs_nonce ? ` nonce="${csp.nonce}"` : ""}>${init_app}<\/script>
 		`;
   }
@@ -2977,7 +3247,7 @@ ${indent}}`);
   }
   const html = options2.templates.app({
     head: head.build(),
-    body: body2,
+    body,
     assets: assets$1,
     nonce: (
       /** @type {string} */
@@ -3079,6 +3349,7 @@ class Head {
   }
 }
 class PageNodes {
+  /** All layout nodes and the page node, if any */
   data;
   /**
    * @param {Array<import('types').SSRNode | undefined>} nodes
@@ -3242,6 +3513,7 @@ async function respond_with_error({
       status,
       error: await handle_error_and_jsonify(event, event_state, options2, error2),
       branch,
+      error_components: [],
       fetched,
       event,
       event_state,
@@ -3279,15 +3551,14 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
   const module = await remotes[hash2]();
   const fn = module.default[name];
   if (!fn) error(404);
-  const info = fn.__;
+  const internals = fn.__;
   const transport = options2.hooks.transport;
   event.tracing.current.setAttributes({
-    "sveltekit.remote.call.type": info.type,
-    "sveltekit.remote.call.name": info.name
+    "sveltekit.remote.call.type": internals.type,
+    "sveltekit.remote.call.name": internals.name
   });
-  let form_client_refreshes;
   try {
-    if (info.type === "query_batch") {
+    if (internals.type === "query_batch") {
       if (event.request.method !== "POST") {
         throw new SvelteKitError(
           405,
@@ -3297,9 +3568,12 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
       }
       const { payloads } = await event.request.json();
       const args = await Promise.all(
-        payloads.map((payload2) => parse_remote_arg(payload2, transport))
+        payloads.map((payload3) => parse_remote_arg(payload3, transport))
+      );
+      const results = await with_request_store(
+        { event, state },
+        () => internals.run(args, options2)
       );
-      const results = await with_request_store({ event, state }, () => info.run(args, options2));
       return json(
         /** @type {RemoteFunctionResponse} */
         {
@@ -3308,7 +3582,7 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
         }
       );
     }
-    if (info.type === "form") {
+    if (internals.type === "form") {
       if (event.request.method !== "POST") {
         throw new SvelteKitError(
           405,
@@ -3326,42 +3600,124 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
         );
       }
       const { data: data2, meta, form_data } = await deserialize_binary_form(event.request);
-      form_client_refreshes = meta.remote_refreshes;
+      state.remote.requested = create_requested_map(meta.remote_refreshes);
       if (additional_args && !("id" in data2)) {
         data2.id = JSON.parse(decodeURIComponent(additional_args));
       }
-      const fn2 = info.fn;
+      const fn2 = internals.fn;
       const result = await with_request_store({ event, state }, () => fn2(data2, meta, form_data));
       return json(
         /** @type {RemoteFunctionResponse} */
         {
           type: "result",
           result: stringify(result, transport),
-          refreshes: result.issues ? void 0 : await serialize_refreshes(meta.remote_refreshes)
+          refreshes: result.issues ? void 0 : await serialize_singleflight(state.remote.refreshes),
+          reconnects: result.issues ? void 0 : await serialize_singleflight(state.remote.reconnects)
         }
       );
     }
-    if (info.type === "command") {
-      const { payload: payload2, refreshes } = await event.request.json();
-      const arg = parse_remote_arg(payload2, transport);
+    if (internals.type === "command") {
+      const { payload: payload3, refreshes } = await event.request.json();
+      state.remote.requested = create_requested_map(refreshes);
+      const arg = parse_remote_arg(payload3, transport);
       const data2 = await with_request_store({ event, state }, () => fn(arg));
       return json(
         /** @type {RemoteFunctionResponse} */
         {
           type: "result",
           result: stringify(data2, transport),
-          refreshes: await serialize_refreshes(refreshes)
+          refreshes: await serialize_singleflight(state.remote.refreshes),
+          reconnects: await serialize_singleflight(state.remote.reconnects)
         }
       );
     }
-    const payload = info.type === "prerender" ? additional_args : (
-      /** @type {string} */
-      // new URL(...) necessary because we're hiding the URL from the user in the event object
-      new URL(event.request.url).searchParams.get("payload")
-    );
-    const data = await with_request_store(
+    if (internals.type === "query_live") {
+      let send = function(controller, payload4) {
+        controller.enqueue(encoder.encode(JSON.stringify(payload4) + "\n"));
+      };
+      if (event.request.method !== "GET") {
+        throw new SvelteKitError(
+          405,
+          "Method Not Allowed",
+          `\`query.live\` functions must be invoked via GET request, not ${event.request.method}`
+        );
+      }
+      const payload3 = (
+        /** @type {string} */
+        new URL(event.request.url).searchParams.get("payload")
+      );
+      const generator = internals.run(event, state, parse_remote_arg(payload3, transport));
+      const encoder = new TextEncoder();
+      let closed = false;
+      let result = void 0;
+      async function cancel() {
+        if (closed) return;
+        closed = true;
+        await generator.return(void 0);
+      }
+      event.request.signal.addEventListener("abort", cancel, { once: true });
+      return new Response(
+        new ReadableStream({
+          async pull(controller) {
+            if (event.request.signal.aborted) {
+              await cancel();
+              controller.close();
+              return;
+            }
+            try {
+              while (true) {
+                const { value, done } = await generator.next();
+                if (done) {
+                  await cancel();
+                  controller.close();
+                  return;
+                }
+                if (result !== (result = stringify(value, transport))) {
+                  send(controller, {
+                    type: "result",
+                    result
+                  });
+                  return;
+                }
+              }
+            } catch (error2) {
+              if (!event.request.signal.aborted) {
+                if (error2 instanceof Redirect) {
+                  send(controller, {
+                    type: "redirect",
+                    location: error2.location
+                  });
+                } else {
+                  const status = error2 instanceof HttpError || error2 instanceof SvelteKitError ? error2.status : 500;
+                  send(controller, {
+                    type: "error",
+                    error: await handle_error_and_jsonify(event, state, options2, error2),
+                    status
+                  });
+                }
+              }
+              await cancel();
+              controller.close();
+            }
+          },
+          cancel
+        }),
+        {
+          headers: {
+            "cache-control": "private, no-store",
+            "content-type": "application/x-ndjson"
+          }
+        }
+      );
+    }
+    const payload2 = internals.type === "prerender" ? additional_args : (
+      /** @type {string} */
+      // new URL(...) necessary because we're hiding the URL from the user in the event object
+      new URL(event.request.url).searchParams.get("payload")
+    );
+    const data = await with_request_store(
       { event, state },
-      () => fn(parse_remote_arg(payload, transport))
+      () => fn(parse_remote_arg(payload2, transport))
     );
     return json(
       /** @type {RemoteFunctionResponse} */
@@ -3377,7 +3733,8 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
         {
           type: "redirect",
           location: error2.location,
-          refreshes: await serialize_refreshes(form_client_refreshes)
+          refreshes: await serialize_singleflight(state.remote.refreshes),
+          reconnects: await serialize_singleflight(state.remote.reconnects)
         }
       );
     }
@@ -3399,34 +3756,43 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
       }
     );
   }
-  async function serialize_refreshes(client_refreshes) {
-    const refreshes = state.refreshes ?? {};
-    if (client_refreshes) {
-      for (const key2 of client_refreshes) {
-        if (refreshes[key2] !== void 0) continue;
-        const [hash3, name2, payload] = key2.split("/");
-        const loader = manifest._.remotes[hash3];
-        const fn2 = (await loader?.())?.default?.[name2];
-        if (!fn2) error(400, "Bad Request");
-        refreshes[key2] = with_request_store(
-          { event, state },
-          () => fn2(parse_remote_arg(payload, transport))
-        );
-      }
-    }
-    if (Object.keys(refreshes).length === 0) {
+  async function serialize_singleflight(map) {
+    if (!map || map.size === 0) {
       return void 0;
     }
-    return stringify(
-      Object.fromEntries(
-        await Promise.all(
-          Object.entries(refreshes).map(async ([key2, promise]) => [key2, await promise])
-        )
-      ),
-      transport
+    const results = await Promise.all(
+      Array.from(map, async ([key2, promise]) => {
+        try {
+          return [key2, { type: "result", data: await promise }];
+        } catch (error2) {
+          const status = error2 instanceof HttpError || error2 instanceof SvelteKitError ? error2.status : 500;
+          return [
+            key2,
+            {
+              type: "error",
+              status,
+              error: await handle_error_and_jsonify(event, state, options2, error2)
+            }
+          ];
+        }
+      })
     );
+    return stringify(Object.fromEntries(results), transport);
   }
 }
+function create_requested_map(refreshes) {
+  const requested = /* @__PURE__ */ new Map();
+  for (const key2 of refreshes ?? []) {
+    const parts = split_remote_key(key2);
+    const existing = requested.get(parts.id);
+    if (existing) {
+      existing.push(parts.payload);
+    } else {
+      requested.set(parts.id, [parts.payload]);
+    }
+  }
+  return requested;
+}
 async function handle_remote_form_post(event, state, manifest, id) {
   return record_span({
     name: "sveltekit.remote.form.post",
@@ -3468,7 +3834,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
   }
   try {
     const fn = (
-      /** @type {RemoteInfo & { type: 'form' }} */
+      /** @type {RemoteFormInternals} */
       /** @type {any} */
       form.__.fn
     );
@@ -3516,7 +3882,7 @@ async function render_page(event, event_state, page, options2, manifest, state,
   }
   try {
     const leaf_node = (
-      /** @type {import('types').SSRNode} */
+      /** @type {SSRNode} */
       nodes.page()
     );
     let status = 200;
@@ -3556,9 +3922,17 @@ async function render_page(event, event_state, page, options2, manifest, state,
     const ssr = nodes.ssr();
     const csr = nodes.csr();
     if (ssr === false && !(state.prerendering && should_prerender_data)) {
-      if (BROWSER && action_result && !event.request.headers.has("x-sveltekit-action")) ;
+      if (DEV && action_result && !event.request.headers.has("x-sveltekit-action")) ;
       return await render_response({
-        branch: [],
+        // provide nodes without running load functions so that the styles and
+        // fonts are linked in the head before CSR takes over
+        branch: compact(nodes.data).map((node) => {
+          return {
+            node,
+            data: null,
+            server_data: null
+          };
+        }),
         fetched,
         page_config: {
           ssr: false,
@@ -3642,10 +4016,8 @@ async function render_page(event, event_state, page, options2, manifest, state,
         }
       });
     });
-    for (const p of server_promises) p.catch(() => {
-    });
-    for (const p of load_promises) p.catch(() => {
-    });
+    for (const p of server_promises) p.catch(noop);
+    for (const p of load_promises) p.catch(noop);
     for (let i = 0; i < nodes.data.length; i += 1) {
       const node = nodes.data[i];
       if (node) {
@@ -3657,13 +4029,13 @@ async function render_page(event, event_state, page, options2, manifest, state,
           const err = normalize_error(e);
           if (err instanceof Redirect) {
             if (state.prerendering && should_prerender_data) {
-              const body2 = JSON.stringify({
+              const body = JSON.stringify({
                 type: "redirect",
                 location: err.location
               });
               state.prerendering.dependencies.set(data_pathname, {
-                response: text(body2),
-                body: body2
+                response: text(body),
+                body
               });
             }
             return redirect_response(err.status, err.location);
@@ -3682,6 +4054,11 @@ async function render_page(event, event_state, page, options2, manifest, state,
               data_serializer.set_max_nodes(j + 1);
               const layouts = compact(branch.slice(0, j + 1));
               const nodes2 = new PageNodes(layouts.map((layout) => layout.node));
+              const error_branch = layouts.concat({
+                node: node2,
+                data: null,
+                server_data: null
+              });
               return await render_response({
                 event,
                 event_state,
@@ -3695,11 +4072,14 @@ async function render_page(event, event_state, page, options2, manifest, state,
                 },
                 status: status2,
                 error: error2,
-                branch: layouts.concat({
-                  node: node2,
-                  data: null,
-                  server_data: null
-                }),
+                error_components: await load_error_components(
+                  options2,
+                  ssr,
+                  error_branch,
+                  page,
+                  manifest
+                ),
+                branch: error_branch,
                 fetched,
                 data_serializer
               });
@@ -3736,10 +4116,11 @@ async function render_page(event, event_state, page, options2, manifest, state,
       },
       status,
       error: null,
-      branch: ssr === false ? [] : compact(branch),
+      branch: compact(branch),
       action_result,
       fetched,
-      data_serializer: ssr === false ? server_data_serializer(event, event_state, options2) : data_serializer
+      data_serializer: !ssr ? server_data_serializer(event, event_state, options2) : data_serializer,
+      error_components: await load_error_components(options2, ssr, branch, page, manifest)
     });
   } catch (e) {
     if (e instanceof Redirect) {
@@ -3757,14 +4138,25 @@ async function render_page(event, event_state, page, options2, manifest, state,
     });
   }
 }
-function once(fn) {
-  let done = false;
-  let result;
-  return () => {
-    if (done) return result;
-    done = true;
-    return result = fn();
-  };
+async function load_error_components(options2, ssr, branch, page, manifest) {
+  let error_components;
+  if (options2.server_error_boundaries && ssr) {
+    let last_idx = -1;
+    error_components = await Promise.all(
+      // eslint-disable-next-line @typescript-eslint/await-thenable
+      branch.map((b, i) => {
+        if (i === 0) return void 0;
+        if (!b) return null;
+        i--;
+        while (i > last_idx + 1 && page.errors[i] === void 0) i -= 1;
+        last_idx = i;
+        const idx = page.errors[i];
+        if (idx == null) return void 0;
+        return manifest._.nodes[idx]?.().then((e) => e.component?.()).catch(() => void 0);
+      }).filter((e) => e !== null)
+    );
+  }
+  return error_components;
 }
 async function render_data(event, event_state, route, options2, manifest, state, invalidated_data_nodes, trailing_slash) {
   if (!route.page) {
@@ -3910,7 +4302,7 @@ function requireDist() {
   dist.stringifyCookie = stringifyCookie;
   dist.stringifySetCookie = stringifySetCookie;
   dist.serialize = stringifySetCookie;
-  dist.parseSetCookie = parseSetCookie2;
+  dist.parseSetCookie = parseSetCookie;
   dist.stringifySetCookie = stringifySetCookie;
   dist.serialize = stringifySetCookie;
   const cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
@@ -4047,7 +4439,7 @@ function requireDist() {
     }
     return str;
   }
-  function parseSetCookie2(str, options2) {
+  function parseSetCookie(str, options2) {
     const dec = options2?.decode || decode;
     const len = str.length;
     const endIdx = endIndex(str, 0, len);
@@ -4310,193 +4702,6 @@ function add_cookies_to_headers(headers2, cookies) {
     }
   }
 }
-var defaultParseOptions = {
-  decodeValues: true,
-  map: false,
-  silent: false,
-  split: "auto"
-  // auto = split strings but not arrays
-};
-function isForbiddenKey(key2) {
-  return typeof key2 !== "string" || key2 in {};
-}
-function createNullObj() {
-  return /* @__PURE__ */ Object.create(null);
-}
-function isNonEmptyString(str) {
-  return typeof str === "string" && !!str.trim();
-}
-function parseString(setCookieValue, options2) {
-  var parts = setCookieValue.split(";").filter(isNonEmptyString);
-  var nameValuePairStr = parts.shift();
-  var parsed = parseNameValuePair(nameValuePairStr);
-  var name = parsed.name;
-  var value = parsed.value;
-  options2 = options2 ? Object.assign({}, defaultParseOptions, options2) : defaultParseOptions;
-  if (isForbiddenKey(name)) {
-    return null;
-  }
-  try {
-    value = options2.decodeValues ? decodeURIComponent(value) : value;
-  } catch (e) {
-    console.error(
-      "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
-      e
-    );
-  }
-  var cookie = createNullObj();
-  cookie.name = name;
-  cookie.value = value;
-  parts.forEach(function(part) {
-    var sides = part.split("=");
-    var key2 = sides.shift().trimLeft().toLowerCase();
-    if (isForbiddenKey(key2)) {
-      return;
-    }
-    var value2 = sides.join("=");
-    if (key2 === "expires") {
-      cookie.expires = new Date(value2);
-    } else if (key2 === "max-age") {
-      var n = parseInt(value2, 10);
-      if (!Number.isNaN(n)) cookie.maxAge = n;
-    } else if (key2 === "secure") {
-      cookie.secure = true;
-    } else if (key2 === "httponly") {
-      cookie.httpOnly = true;
-    } else if (key2 === "samesite") {
-      cookie.sameSite = value2;
-    } else if (key2 === "partitioned") {
-      cookie.partitioned = true;
-    } else if (key2) {
-      cookie[key2] = value2;
-    }
-  });
-  return cookie;
-}
-function parseNameValuePair(nameValuePairStr) {
-  var name = "";
-  var value = "";
-  var nameValueArr = nameValuePairStr.split("=");
-  if (nameValueArr.length > 1) {
-    name = nameValueArr.shift();
-    value = nameValueArr.join("=");
-  } else {
-    value = nameValuePairStr;
-  }
-  return { name, value };
-}
-function parseSetCookie(input, options2) {
-  options2 = options2 ? Object.assign({}, defaultParseOptions, options2) : defaultParseOptions;
-  if (!input) {
-    if (!options2.map) {
-      return [];
-    } else {
-      return createNullObj();
-    }
-  }
-  if (input.headers) {
-    if (typeof input.headers.getSetCookie === "function") {
-      input = input.headers.getSetCookie();
-    } else if (input.headers["set-cookie"]) {
-      input = input.headers["set-cookie"];
-    } else {
-      var sch = input.headers[Object.keys(input.headers).find(function(key2) {
-        return key2.toLowerCase() === "set-cookie";
-      })];
-      if (!sch && input.headers.cookie && !options2.silent) {
-        console.warn(
-          "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-        );
-      }
-      input = sch;
-    }
-  }
-  var split = options2.split;
-  var isArray = Array.isArray(input);
-  if (split === "auto") {
-    split = !isArray;
-  }
-  if (!isArray) {
-    input = [input];
-  }
-  input = input.filter(isNonEmptyString);
-  if (split) {
-    input = input.map(splitCookiesString).flat();
-  }
-  if (!options2.map) {
-    return input.map(function(str) {
-      return parseString(str, options2);
-    }).filter(Boolean);
-  } else {
-    var cookies = createNullObj();
-    return input.reduce(function(cookies2, str) {
-      var cookie = parseString(str, options2);
-      if (cookie && !isForbiddenKey(cookie.name)) {
-        cookies2[cookie.name] = cookie;
-      }
-      return cookies2;
-    }, cookies);
-  }
-}
-function splitCookiesString(cookiesString) {
-  if (Array.isArray(cookiesString)) {
-    return cookiesString;
-  }
-  if (typeof cookiesString !== "string") {
-    return [];
-  }
-  var cookiesStrings = [];
-  var pos = 0;
-  var start;
-  var ch;
-  var lastComma;
-  var nextStart;
-  var cookiesSeparatorFound;
-  function skipWhitespace() {
-    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
-      pos += 1;
-    }
-    return pos < cookiesString.length;
-  }
-  function notSpecialChar() {
-    ch = cookiesString.charAt(pos);
-    return ch !== "=" && ch !== ";" && ch !== ",";
-  }
-  while (pos < cookiesString.length) {
-    start = pos;
-    cookiesSeparatorFound = false;
-    while (skipWhitespace()) {
-      ch = cookiesString.charAt(pos);
-      if (ch === ",") {
-        lastComma = pos;
-        pos += 1;
-        skipWhitespace();
-        nextStart = pos;
-        while (pos < cookiesString.length && notSpecialChar()) {
-          pos += 1;
-        }
-        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-          cookiesSeparatorFound = true;
-          pos = nextStart;
-          cookiesStrings.push(cookiesString.substring(start, lastComma));
-          start = pos;
-        } else {
-          pos = lastComma + 1;
-        }
-      } else {
-        pos += 1;
-      }
-    }
-    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
-      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
-    }
-  }
-  return cookiesStrings;
-}
-parseSetCookie.parseSetCookie = parseSetCookie;
-parseSetCookie.parse = parseSetCookie;
-parseSetCookie.parseString = parseString;
-parseSetCookie.splitCookiesString = splitCookiesString;
 function create_fetch({ event, options: options2, manifest, state, get_cookie_header, set_internal }) {
   const server_fetch = async (info, init2) => {
     const original_request = normalize_fetch_input(info, init2, event.url);
@@ -4574,20 +4779,17 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
           );
         }
         const response = await internal_fetch(request, options2, manifest, state);
-        const set_cookie = response.headers.get("set-cookie");
-        if (set_cookie) {
-          for (const str of splitCookiesString(set_cookie)) {
-            const { name, value, ...options3 } = parseString(str, {
-              decodeValues: false
-            });
-            const path = options3.path ?? (url.pathname.split("/").slice(0, -1).join("/") || "/");
-            set_internal(name, value, {
-              path,
-              encode: (value2) => value2,
-              .../** @type {import('cookie').CookieSerializeOptions} */
-              options3
-            });
-          }
+        for (const str of get_set_cookies(response.headers)) {
+          const { name, value, ...options3 } = parseString(str, {
+            decodeValues: false
+          });
+          const path = options3.path ?? (url.pathname.split("/").slice(0, -1).join("/") || "/");
+          set_internal(name, value, {
+            path,
+            encode: (value2) => value2,
+            .../** @type {import('cookie').CookieSerializeOptions} */
+            options3
+          });
         }
         return response;
       }
@@ -4595,8 +4797,7 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
   };
   return (input, init2) => {
     const response = server_fetch(input, init2);
-    response.catch(() => {
-    });
+    response.catch(noop);
     return response;
   };
 }
@@ -4611,8 +4812,7 @@ async function internal_fetch(request, options2, manifest, state) {
     if (request.signal.aborted) {
       throw new DOMException("The operation was aborted.", "AbortError");
     }
-    let remove_abort_listener = () => {
-    };
+    let remove_abort_listener = noop;
     const abort_promise = new Promise((_, reject) => {
       const on_abort = () => {
         reject(new DOMException("The operation was aborted.", "AbortError"));
@@ -4636,11 +4836,13 @@ async function internal_fetch(request, options2, manifest, state) {
     });
   }
 }
-let body;
+let payload;
 let etag;
 let headers;
 function get_public_env(request) {
-  body ??= `export const env=${JSON.stringify(public_env)}`;
+  const script = request.url.endsWith(".script.js");
+  const env = public_env;
+  payload ??= uneval(env);
   etag ??= `W/${Date.now()}`;
   headers ??= new Headers({
     "content-type": "application/javascript; charset=utf-8",
@@ -4649,7 +4851,10 @@ function get_public_env(request) {
   if (request.headers.get("if-none-match") === etag) {
     return new Response(void 0, { status: 304, headers });
   }
-  return new Response(body, { headers });
+  if (script) {
+    return new Response(`globalThis.__sveltekit_sw={env:${payload}}`, { headers });
+  }
+  return new Response(`export const env=${payload}`, { headers });
 }
 const default_transform = ({ html }) => html;
 const default_filter = () => false;
@@ -4708,7 +4913,18 @@ async function internal_respond(request, options2, manifest, state) {
     tracing: {
       record_span
     },
-    is_in_remote_function: false
+    remote: {
+      data: null,
+      forms: null,
+      refreshes: null,
+      requested: null,
+      reconnects: null,
+      batches: null,
+      live_iterators: null
+    },
+    is_in_remote_function: false,
+    is_in_render: false,
+    is_in_universal_load: false
   };
   const event = {
     cookies,
@@ -4780,10 +4996,18 @@ async function internal_respond(request, options2, manifest, state) {
       if (state.prerendering) state.prerendering.inside_reroute = prerendering_reroute_state;
     }
   }
+  let resolve_opts = {
+    transformPageChunk: default_transform,
+    filterSerializedResponseHeaders: default_filter,
+    preload: default_preload
+  };
+  let trailing_slash = "never";
+  let page_nodes;
   try {
     resolved_path = decode_pathname(resolved_path);
   } catch {
-    return text("Malformed URI", { status: 400 });
+    resolved_path = null;
+    return await handle();
   }
   if (
     // the resolved path has been decoded so it should be compared to the decoded url pathname
@@ -4817,7 +5041,7 @@ async function internal_respond(request, options2, manifest, state) {
   if (is_route_resolution_request) {
     return resolve_route(resolved_path, new URL(request.url), manifest);
   }
-  if (resolved_path === `/${app_dir}/env.js`) {
+  if (resolved_path === `/${app_dir}/env.js` || resolved_path === `/${app_dir}/env.script.js`) {
     return get_public_env(request);
   }
   if (!remote_id && resolved_path.startsWith(`/${app_dir}`)) {
@@ -4834,24 +5058,18 @@ async function internal_respond(request, options2, manifest, state) {
       event.params = result.params;
     }
   }
-  let resolve_opts = {
-    transformPageChunk: default_transform,
-    filterSerializedResponseHeaders: default_filter,
-    preload: default_preload
-  };
-  let trailing_slash = "never";
   try {
-    const page_nodes = route?.page ? new PageNodes(await load_page_nodes(route.page, manifest)) : void 0;
+    page_nodes = route?.page ? new PageNodes(await load_page_nodes(route.page, manifest)) : void 0;
     if (route && !remote_id) {
       if (url.pathname === base || url.pathname === base + "/") {
         trailing_slash = "always";
       } else if (page_nodes) {
-        if (BROWSER) ;
+        if (DEV) ;
         trailing_slash = page_nodes.trailing_slash();
       } else if (route.endpoint) {
         const node = await route.endpoint();
         trailing_slash = node.trailingSlash ?? "never";
-        if (BROWSER) ;
+        if (DEV) ;
       }
       if (!is_data_request) {
         const normalized = normalize_path(url.pathname, trailing_slash);
@@ -4879,14 +5097,28 @@ async function internal_respond(request, options2, manifest, state) {
           config = page_nodes.get_config() ?? config;
           prerender = page_nodes.prerender();
         }
-        if (state.before_handle) {
-          state.before_handle(event, config, prerender);
-        }
         if (state.emulator?.platform) {
           event.platform = await state.emulator.platform({ config, prerender });
         }
+        if (state.before_handle) {
+          return await state.before_handle(event, config, prerender, handle);
+        }
       }
     }
+    return await handle();
+  } catch (e) {
+    if (e instanceof Redirect) {
+      try {
+        const response = is_data_request || remote_id ? redirect_json_response(e) : route?.page && is_action_json_request(event) ? action_json_redirect(e) : redirect_response(e.status, e.location);
+        add_cookies_to_headers(response.headers, new_cookies.values());
+        return response;
+      } catch (err) {
+        return await handle_fatal_error(event, event_state, options2, err);
+      }
+    }
+    return await handle_fatal_error(event, event_state, options2, e);
+  }
+  async function handle() {
     set_trailing_slash(trailing_slash);
     if (state.prerendering && !state.prerendering.fallback && !state.prerendering.inside_reroute) {
       disable_search(url);
@@ -4897,7 +5129,6 @@ async function internal_respond(request, options2, manifest, state) {
         "http.route": event.route.id || "unknown",
         "http.method": event.request.method,
         "http.url": event.url.href,
-        "sveltekit.is_data_request": is_data_request,
         "sveltekit.is_sub_request": event.isSubRequest
       },
       fn: async (root_span) => {
@@ -4909,7 +5140,6 @@ async function internal_respond(request, options2, manifest, state) {
             current: root_span
           }
         };
-        event_state.allows_commands = MUTATIVE_METHODS.includes(request.method);
         return await with_request_store(
           { event: traced_event, state: event_state },
           () => options2.hooks.handle({
@@ -4963,17 +5193,13 @@ async function internal_respond(request, options2, manifest, state) {
       );
       if (if_none_match_value === etag2) {
         const headers22 = new Headers({ etag: etag2 });
-        for (const key2 of [
-          "cache-control",
-          "content-location",
-          "date",
-          "expires",
-          "vary",
-          "set-cookie"
-        ]) {
+        for (const key2 of ["cache-control", "content-location", "date", "expires", "vary"]) {
           const value = response.headers.get(key2);
           if (value) headers22.set(key2, value);
         }
+        for (const cookie of get_set_cookies(response.headers)) {
+          headers22.append("set-cookie", cookie);
+        }
         return new Response(void 0, {
           status: 304,
           headers: headers22
@@ -4991,15 +5217,8 @@ async function internal_respond(request, options2, manifest, state) {
       }
     }
     return response;
-  } catch (e) {
-    if (e instanceof Redirect) {
-      const response = is_data_request || remote_id ? redirect_json_response(e) : route?.page && is_action_json_request(event) ? action_json_redirect(e) : redirect_response(e.status, e.location);
-      add_cookies_to_headers(response.headers, new_cookies.values());
-      return response;
-    }
-    return await handle_fatal_error(event, event_state, options2, e);
   }
-  async function resolve2(event2, page_nodes, opts) {
+  async function resolve2(event2, page_nodes2, opts) {
     try {
       if (opts) {
         resolve_opts = {
@@ -5008,6 +5227,22 @@ async function internal_respond(request, options2, manifest, state) {
           preload: opts.preload || default_preload
         };
       }
+      if (resolved_path === null) {
+        return await respond_with_error({
+          event: event2,
+          event_state,
+          options: options2,
+          manifest,
+          state,
+          status: 400,
+          error: new SvelteKitError(
+            400,
+            "Malformed URI",
+            `Failed to decode URI: ${event2.url.pathname}`
+          ),
+          resolve_opts
+        });
+      }
       if (options2.hash_routing || state.prerendering?.fallback) {
         return await render_response({
           event: event2,
@@ -5018,7 +5253,17 @@ async function internal_respond(request, options2, manifest, state) {
           page_config: { ssr: false, csr: true },
           status: 200,
           error: null,
-          branch: [],
+          branch: [
+            // include the root layout because it applies to every page
+            {
+              node: (
+                /** @type {SSRNode} */
+                await manifest._.nodes[0]()
+              ),
+              data: null,
+              server_data: null
+            }
+          ],
           fetched: [],
           resolve_opts,
           data_serializer: server_data_serializer(event2, event_state, options2)
@@ -5047,7 +5292,7 @@ async function internal_respond(request, options2, manifest, state) {
         } else if (route.endpoint && (!route.page || is_endpoint_request(event2))) {
           response2 = await render_endpoint(event2, event_state, await route.endpoint(), state);
         } else if (route.page) {
-          if (!page_nodes) {
+          if (!page_nodes2) {
             throw new Error("page_nodes not found. This should never happen");
           } else if (page_methods.has(method)) {
             response2 = await render_page(
@@ -5057,7 +5302,7 @@ async function internal_respond(request, options2, manifest, state) {
               options2,
               manifest,
               state,
-              page_nodes,
+              page_nodes2,
               resolve_opts
             );
           } else {
@@ -5112,7 +5357,6 @@ async function internal_respond(request, options2, manifest, state) {
         });
       }
       if (state.depth === 0) {
-        if (BROWSER && event2.url.pathname === "/.well-known/appspecific/com.chrome.devtools.json") ;
         return await respond_with_error({
           event: event2,
           event_state,
@@ -5245,8 +5489,7 @@ class Server {
             console.error("Remote function schema validation failed:", issues);
             return { message: "Bad Request" };
           }),
-          reroute: module.reroute || (() => {
-          }),
+          reroute: module.reroute || noop,
           transport: module.transport || {}
         };
         set_app({