@phosart/devtool 0.2.55 → 0.2.57

package/build/server/index.js

@@ -1,9 +1,9 @@
-import { j as json, t as text, R as Redirect, S as SvelteKitError, H as HttpError, e as error, A as ActionFailure } from './chunks/index-CoD1IJuy.js';
+import { S as SvelteKitError, j as json, t as text, R as Redirect, H as HttpError, e as error, A as ActionFailure } from './chunks/index-CoD1IJuy.js';
 import { w as with_request_store } from './chunks/event-ByDKS2H7.js';
 import { b as base, a as app_dir, e as exec, c as assets, r as relative, o as override, d as reset } from './chunks/routing-C4Egnc9A.js';
-import { t as text_decoder, b as base64_decode, d as define_property, o as object_prototype, a as array_prototype, g as get_descriptor, i as is_extensible, c as array_from, e as get_prototype_of, f as is_array, h as deferred, r as run_all, j as index_of, s as setContext, k as decode_pathname, l as decode_params, n as normalize_path, m as disable_search, v as validate_layout_server_exports, p as validate_layout_exports, q as validate_page_server_exports, u as validate_page_exports, w as text_encoder, x as resolve, y as make_trackable, z as base64_encode, A as get_relative_path } from './chunks/context-BmNrKtQb.js';
-import { s as safe_equals, e as equals, r as readable, w as writable } from './chunks/index-6Cdu3mod.js';
-import { r as render, L as LEGACY_PROPS, E as ERROR_VALUE, C as COMMENT_NODE, H as HYDRATION_START, a as HYDRATION_ERROR, S as STATE_SYMBOL, U as UNINITIALIZED, D as DERIVED, b as DIRTY, c as CONNECTED, d as CLEAN, M as MAYBE_DIRTY, I as INERT, B as BOUNDARY_EFFECT, e as EFFECT, f as BLOCK_EFFECT, W as WAS_MARKED, i as is_passive_event, g as BRANCH_EFFECT, R as ROOT_EFFECT, h as DESTROYED, j as MANAGED_EFFECT, A as ASYNC, k as HEAD_EFFECT, l as REACTION_IS_UPDATING, m as EFFECT_RAN, n as EFFECT_PRESERVED, o as EFFECT_TRANSPARENT, p as EAGER_EFFECT, q as STALE_REACTION, s as HYDRATION_END, t as RENDER_EFFECT, u as HYDRATION_START_ELSE, v as USER_EFFECT } from './chunks/index2-DHJrk8_o.js';
+import { t as text_decoder, b as base64_decode, d as define_property, o as object_prototype, a as array_prototype, g as get_descriptor, i as is_extensible, c as array_from, e as get_prototype_of, f as is_array, h as deferred, r as run_all, j as index_of, s as setContext, k as decode_pathname, l as decode_params, n as normalize_path, m as disable_search, v as validate_layout_server_exports, p as validate_layout_exports, q as validate_page_server_exports, u as validate_page_exports, w as text_encoder, x as resolve, y as make_trackable, z as base64_encode, A as get_relative_path } from './chunks/exports-DTikbzSR.js';
+import { 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, r as render, L as LEGACY_PROPS, C as CONNECTED, E as ERROR_VALUE, c as COMMENT_NODE, H as HYDRATION_START, d as HYDRATION_ERROR, S as STATE_SYMBOL, U as UNINITIALIZED, f as DERIVED, h as DIRTY, M as MAYBE_DIRTY, j as CLEAN, I as INERT, k as EFFECT, B as BLOCK_EFFECT, W as WAS_MARKED, l as is_passive_event, m as BRANCH_EFFECT, R as ROOT_EFFECT, n as RENDER_EFFECT, o as MANAGED_EFFECT, p as DESTROYED, A as ASYNC, q as HEAD_EFFECT, t as REACTION_IS_UPDATING, u as EFFECT_RAN, v as EFFECT_PRESERVED, w as EFFECT_TRANSPARENT, x as BOUNDARY_EFFECT, y as EAGER_EFFECT, z as STALE_REACTION, F as HYDRATION_END, G as HYDRATION_START_ELSE, J as USER_EFFECT, K as uneval } from './chunks/index-Z8eOP0z5.js';
+import { s as safe_equals, e as equals, r as readable, w as writable } from './chunks/index2-RKMiVZcy.js';
 
 const BROWSER = false;
 
@@ -23,94 +23,6 @@ function merge_tracing(event_like, current) {
 	};
 }
 
-const escaped = {
-  "<": "\\u003C",
-  "\\": "\\\\",
-  "\b": "\\b",
-  "\f": "\\f",
-  "\n": "\\n",
-  "\r": "\\r",
-  "	": "\\t",
-  "\u2028": "\\u2028",
-  "\u2029": "\\u2029"
-};
-class DevalueError extends Error {
-  /**
-   * @param {string} message
-   * @param {string[]} keys
-   * @param {any} [value] - The value that failed to be serialized
-   * @param {any} [root] - The root value being serialized
-   */
-  constructor(message, keys, value, root) {
-    super(message);
-    this.name = "DevalueError";
-    this.path = keys.join("");
-    this.value = value;
-    this.root = root;
-  }
-}
-function is_primitive(thing) {
-  return Object(thing) !== thing;
-}
-const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(
-  Object.prototype
-).sort().join("\0");
-function is_plain_object(thing) {
-  const proto = Object.getPrototypeOf(thing);
-  return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
-}
-function get_type(thing) {
-  return Object.prototype.toString.call(thing).slice(8, -1);
-}
-function get_escaped_char(char) {
-  switch (char) {
-    case '"':
-      return '\\"';
-    case "<":
-      return "\\u003C";
-    case "\\":
-      return "\\\\";
-    case "\n":
-      return "\\n";
-    case "\r":
-      return "\\r";
-    case "	":
-      return "\\t";
-    case "\b":
-      return "\\b";
-    case "\f":
-      return "\\f";
-    case "\u2028":
-      return "\\u2028";
-    case "\u2029":
-      return "\\u2029";
-    default:
-      return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
-  }
-}
-function stringify_string(str) {
-  let result = "";
-  let last_pos = 0;
-  const len = str.length;
-  for (let i = 0; i < len; i += 1) {
-    const char = str[i];
-    const replacement = get_escaped_char(char);
-    if (replacement) {
-      result += str.slice(last_pos, i) + replacement;
-      last_pos = i + 1;
-    }
-  }
-  return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
-}
-function enumerable_symbols(object) {
-  return Object.getOwnPropertySymbols(object).filter(
-    (symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable
-  );
-}
-const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
-function stringify_key(key) {
-  return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
-}
 function encode64(arraybuffer) {
   const dv = new DataView(arraybuffer);
   let binaryString = "";
@@ -200,6 +112,7 @@ function unflatten(parsed, revivers) {
     parsed
   );
   const hydrated = Array(values.length);
+  let hydrating = null;
   function hydrate(index, standalone = false) {
     if (index === UNDEFINED) return void 0;
     if (index === NAN) return NaN;
@@ -222,7 +135,14 @@ function unflatten(parsed, revivers) {
           if (typeof i !== "number") {
             i = values.push(value[1]) - 1;
           }
-          return hydrated[index] = reviver(hydrate(i));
+          hydrating ??= /* @__PURE__ */ new Set();
+          if (hydrating.has(i)) {
+            throw new Error("Invalid circular reference");
+          }
+          hydrating.add(i);
+          hydrated[index] = reviver(hydrate(i));
+          hydrating.delete(i);
+          return hydrated[index];
         }
         switch (type) {
           case "Date":
@@ -269,13 +189,20 @@ function unflatten(parsed, revivers) {
           case "Float64Array":
           case "BigInt64Array":
           case "BigUint64Array": {
+            if (values[value[1]][0] !== "ArrayBuffer") {
+              throw new Error("Invalid data");
+            }
             const TypedArrayConstructor = globalThis[type];
-            const typedArray = new TypedArrayConstructor(hydrate(value[1]));
+            const buffer = hydrate(value[1]);
+            const typedArray = new TypedArrayConstructor(buffer);
             hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
             break;
           }
           case "ArrayBuffer": {
             const base64 = value[1];
+            if (typeof base64 !== "string") {
+              throw new Error("Invalid ArrayBuffer encoding");
+            }
             const arraybuffer = decode64(base64);
             hydrated[index] = arraybuffer;
             break;
@@ -361,14 +288,14 @@ function stringify$1(value, reducers) {
     }
     let str = "";
     if (is_primitive(thing)) {
-      str = stringify_primitive$1(thing);
+      str = stringify_primitive(thing);
     } else {
       const type = get_type(thing);
       switch (type) {
         case "Number":
         case "String":
         case "Boolean":
-          str = `["Object",${stringify_primitive$1(thing)}]`;
+          str = `["Object",${stringify_primitive(thing)}]`;
           break;
         case "BigInt":
           str = `["BigInt",${thing}]`;
@@ -412,7 +339,7 @@ function stringify$1(value, reducers) {
           str = '["Map"';
           for (const [key, value2] of thing) {
             keys.push(
-              `.get(${is_primitive(key) ? stringify_primitive$1(key) : "..."})`
+              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
             );
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
@@ -503,7 +430,7 @@ function stringify$1(value, reducers) {
   if (index < 0) return `${index}`;
   return `[${stringified.join(",")}]`;
 }
-function stringify_primitive$1(thing) {
+function stringify_primitive(thing) {
   const type = typeof thing;
   if (type === "string") return stringify_string(thing);
   if (thing instanceof String) return stringify_string(thing.toString());
@@ -550,17 +477,22 @@ function convert_formdata(data) {
 }
 const BINARY_FORM_CONTENT_TYPE = "application/x-sveltekit-formdata";
 const BINARY_FORM_VERSION = 0;
+const HEADER_BYTES = 1 + 4 + 2;
 async function deserialize_binary_form(request) {
   if (request.headers.get("content-type") !== BINARY_FORM_CONTENT_TYPE) {
     const form_data = await request.formData();
     return { data: convert_formdata(form_data), meta: {}, form_data };
   }
   if (!request.body) {
-    throw new Error("Could not deserialize binary form: no 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 = [];
-  async function get_chunk(index) {
+  function get_chunk(index) {
     if (index in chunks) return chunks[index];
     let i = chunks.length;
     while (i <= index) {
@@ -586,8 +518,7 @@ async function deserialize_binary_form(request) {
     if (offset + length <= chunk_start + start_chunk.byteLength) {
       return start_chunk.subarray(offset - chunk_start, offset + length - chunk_start);
     }
-    const buffer = new Uint8Array(length);
-    buffer.set(start_chunk.subarray(offset - chunk_start));
+    const chunks2 = [start_chunk.subarray(offset - chunk_start)];
     let cursor = start_chunk.byteLength - offset + chunk_start;
     while (cursor < length) {
       chunk_index++;
@@ -596,35 +527,47 @@ async function deserialize_binary_form(request) {
       if (chunk.byteLength > length - cursor) {
         chunk = chunk.subarray(0, length - cursor);
       }
+      chunks2.push(chunk);
+      cursor += chunk.byteLength;
+    }
+    const buffer = new Uint8Array(length);
+    cursor = 0;
+    for (const chunk of chunks2) {
       buffer.set(chunk, cursor);
       cursor += chunk.byteLength;
     }
     return buffer;
   }
-  const header = await get_buffer(0, 1 + 4 + 2);
-  if (!header) throw new Error("Could not deserialize binary form: too short");
+  const header = await get_buffer(0, HEADER_BYTES);
+  if (!header) throw deserialize_error("too short");
   if (header[0] !== BINARY_FORM_VERSION) {
-    throw new Error(
-      `Could not deserialize binary form: got version ${header[0]}, expected version ${BINARY_FORM_VERSION}`
-    );
+    throw deserialize_error(`got version ${header[0]}, expected version ${BINARY_FORM_VERSION}`);
   }
   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);
-  const data_buffer = await get_buffer(1 + 4 + 2, data_length);
-  if (!data_buffer) throw new Error("Could not deserialize binary form: data too short");
+  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;
   let files_start_offset;
   if (file_offsets_length > 0) {
-    const file_offsets_buffer = await get_buffer(1 + 4 + 2 + data_length, file_offsets_length);
-    if (!file_offsets_buffer)
-      throw new Error("Could not deserialize binary form: file offset table too short");
+    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");
     file_offsets = /** @type {Array<number>} */
     JSON.parse(text_decoder.decode(file_offsets_buffer));
-    files_start_offset = 1 + 4 + 2 + data_length + file_offsets_length;
+    files_start_offset = HEADER_BYTES + data_length + file_offsets_length;
   }
   const [data, meta] = parse(text_decoder.decode(data_buffer), {
     File: ([name, type, size, last_modified, index]) => {
+      if (files_start_offset + file_offsets[index] + size > content_length) {
+        throw deserialize_error("file data overflow");
+      }
       return new Proxy(
         new LazyFile(
           name,
@@ -651,6 +594,9 @@ async function deserialize_binary_form(request) {
   })();
   return { data, meta, form_data: null };
 }
+function deserialize_error(message) {
+  return new SvelteKitError(400, "Bad Request", `Could not deserialize binary form: ${message}`);
+}
 class LazyFile {
   /** @type {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} */
   #get_chunk;
@@ -745,7 +691,7 @@ class LazyFile {
         chunk_index++;
         let chunk = await this.#get_chunk(chunk_index);
         if (!chunk) {
-          controller.error("Could not deserialize binary form: incomplete file data");
+          controller.error("incomplete file data");
           controller.close();
           return;
         }
@@ -784,7 +730,7 @@ function deep_set(object, keys, value) {
     const key = keys[i];
     check_prototype_pollution(key);
     const is_array = /^\d+$/.test(keys[i + 1]);
-    const exists = key in current;
+    const exists = Object.hasOwn(current, key);
     const inner = current[key];
     if (exists && is_array !== Array.isArray(inner)) {
       throw new Error(`Invalid array key ${keys[i + 1]}`);
@@ -1000,6 +946,39 @@ function invoke_error_boundary(error, effect) {
   }
   throw error;
 }
+const STATUS_MASK = -7169;
+function set_signal_status(signal, status) {
+  signal.f = signal.f & STATUS_MASK | status;
+}
+function update_derived_status(derived) {
+  if ((derived.f & CONNECTED) !== 0 || derived.deps === null) {
+    set_signal_status(derived, CLEAN);
+  } else {
+    set_signal_status(derived, MAYBE_DIRTY);
+  }
+}
+function clear_marked(deps) {
+  if (deps === null) return;
+  for (const dep of deps) {
+    if ((dep.f & DERIVED) === 0 || (dep.f & WAS_MARKED) === 0) {
+      continue;
+    }
+    dep.f ^= WAS_MARKED;
+    clear_marked(
+      /** @type {Derived} */
+      dep.deps
+    );
+  }
+}
+function defer_effect(effect, dirty_effects, maybe_dirty_effects) {
+  if ((effect.f & DIRTY) !== 0) {
+    dirty_effects.add(effect);
+  } else if ((effect.f & MAYBE_DIRTY) !== 0) {
+    maybe_dirty_effects.add(effect);
+  }
+  clear_marked(effect.deps);
+  set_signal_status(effect, CLEAN);
+}
 const batches = /* @__PURE__ */ new Set();
 let current_batch = null;
 let batch_values = null;
@@ -1073,25 +1052,21 @@ class Batch {
   process(root_effects) {
     queued_root_effects = [];
     this.apply();
-    var target = {
-      parent: null,
-      effect: null,
-      effects: [],
-      render_effects: []
-    };
+    var effects = [];
+    var render_effects = [];
     for (const root2 of root_effects) {
-      this.#traverse_effect_tree(root2, target);
+      this.#traverse_effect_tree(root2, effects, render_effects);
     }
     if (!this.is_fork) {
       this.#resolve();
     }
     if (this.is_deferred()) {
-      this.#defer_effects(target.effects);
-      this.#defer_effects(target.render_effects);
+      this.#defer_effects(render_effects);
+      this.#defer_effects(effects);
     } else {
       current_batch = null;
-      flush_queued_effects(target.render_effects);
-      flush_queued_effects(target.effects);
+      flush_queued_effects(render_effects);
+      flush_queued_effects(effects);
       this.#deferred?.resolve();
     }
     batch_values = null;
@@ -1100,31 +1075,27 @@ class Batch {
    * Traverse the effect tree, executing effects or stashing
    * them for later execution as appropriate
    * @param {Effect} root
-   * @param {EffectTarget} target
+   * @param {Effect[]} effects
+   * @param {Effect[]} render_effects
    */
-  #traverse_effect_tree(root2, target) {
+  #traverse_effect_tree(root2, effects, render_effects) {
     root2.f ^= CLEAN;
     var effect = root2.first;
+    var pending_boundary = null;
     while (effect !== null) {
       var flags2 = effect.f;
       var is_branch = (flags2 & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
       var is_skippable_branch = is_branch && (flags2 & CLEAN) !== 0;
       var skip = is_skippable_branch || (flags2 & INERT) !== 0 || this.skipped_effects.has(effect);
-      if ((effect.f & BOUNDARY_EFFECT) !== 0 && effect.b?.is_pending()) {
-        target = {
-          parent: target,
-          effect,
-          effects: [],
-          render_effects: []
-        };
-      }
       if (!skip && effect.fn !== null) {
         if (is_branch) {
           effect.f ^= CLEAN;
+        } else if (pending_boundary !== null && (flags2 & (EFFECT | RENDER_EFFECT | MANAGED_EFFECT)) !== 0) {
+          pending_boundary.b.defer_effect(effect);
         } else if ((flags2 & EFFECT) !== 0) {
-          target.effects.push(effect);
+          effects.push(effect);
         } else if (is_dirty(effect)) {
-          if ((effect.f & BLOCK_EFFECT) !== 0) this.#dirty_effects.add(effect);
+          if ((flags2 & BLOCK_EFFECT) !== 0) this.#dirty_effects.add(effect);
           update_effect(effect);
         }
         var child = effect.first;
@@ -1136,11 +1107,8 @@ class Batch {
       var parent = effect.parent;
       effect = effect.next;
       while (effect === null && parent !== null) {
-        if (parent === target.effect) {
-          this.#defer_effects(target.effects);
-          this.#defer_effects(target.render_effects);
-          target = /** @type {EffectTarget} */
-          target.parent;
+        if (parent === pending_boundary) {
+          pending_boundary = null;
         }
         effect = parent.next;
         parent = parent.parent;
@@ -1151,30 +1119,8 @@ class Batch {
    * @param {Effect[]} effects
    */
   #defer_effects(effects) {
-    for (const e of effects) {
-      if ((e.f & DIRTY) !== 0) {
-        this.#dirty_effects.add(e);
-      } else if ((e.f & MAYBE_DIRTY) !== 0) {
-        this.#maybe_dirty_effects.add(e);
-      }
-      this.#clear_marked(e.deps);
-      set_signal_status(e, CLEAN);
-    }
-  }
-  /**
-   * @param {Value[] | null} deps
-   */
-  #clear_marked(deps) {
-    if (deps === null) return;
-    for (const dep of deps) {
-      if ((dep.f & DERIVED) === 0 || (dep.f & WAS_MARKED) === 0) {
-        continue;
-      }
-      dep.f ^= WAS_MARKED;
-      this.#clear_marked(
-        /** @type {Derived} */
-        dep.deps
-      );
+    for (var i = 0; i < effects.length; i += 1) {
+      defer_effect(effects[i], this.#dirty_effects, this.#maybe_dirty_effects);
     }
   }
   /**
@@ -1184,7 +1130,7 @@ class Batch {
    * @param {any} value
    */
   capture(source2, value) {
-    if (!this.previous.has(source2)) {
+    if (value !== UNINITIALIZED && !this.previous.has(source2)) {
       this.previous.set(source2, value);
     }
     if ((source2.f & ERROR_VALUE) === 0) {
@@ -1231,12 +1177,6 @@ class Batch {
       this.previous.clear();
       var previous_batch_values = batch_values;
       var is_earlier = true;
-      var dummy_target = {
-        parent: null,
-        effect: null,
-        effects: [],
-        render_effects: []
-      };
       for (const batch of batches) {
         if (batch === this) {
           is_earlier = false;
@@ -1269,7 +1209,7 @@ class Batch {
             current_batch = batch;
             batch.apply();
             for (const root2 of queued_root_effects) {
-              batch.#traverse_effect_tree(root2, dummy_target);
+              batch.#traverse_effect_tree(root2, [], []);
             }
             batch.deactivate();
           }
@@ -1539,7 +1479,7 @@ function boundary(node, props, children) {
 class Boundary {
   /** @type {Boundary | null} */
   parent;
-  #pending = false;
+  is_pending = false;
   /** @type {TemplateNode} */
   #anchor;
   /** @type {TemplateNode | null} */
@@ -1563,6 +1503,10 @@ class Boundary {
   #local_pending_count = 0;
   #pending_count = 0;
   #is_creating_fallback = false;
+  /** @type {Set<Effect>} */
+  #dirty_effects = /* @__PURE__ */ new Set();
+  /** @type {Set<Effect>} */
+  #maybe_dirty_effects = /* @__PURE__ */ new Set();
   /**
    * A source containing the number of pending async deriveds/expressions.
    * Only created if `$effect.pending()` is used inside the boundary,
@@ -1588,7 +1532,7 @@ class Boundary {
     this.#children = children;
     this.parent = /** @type {Effect} */
     active_effect.b;
-    this.#pending = !!this.#props.pending;
+    this.is_pending = !!this.#props.pending;
     this.#effect = block(() => {
       active_effect.b = this;
       if (hydrating) {
@@ -1603,6 +1547,9 @@ class Boundary {
           this.#hydrate_pending_content();
         } else {
           this.#hydrate_resolved_content();
+          if (this.#pending_count === 0) {
+            this.is_pending = false;
+          }
         }
       } else {
         var anchor = this.#get_anchor();
@@ -1614,7 +1561,7 @@ class Boundary {
         if (this.#pending_count > 0) {
           this.#show_pending_snippet();
         } else {
-          this.#pending = false;
+          this.is_pending = false;
         }
       }
       return () => {
@@ -1631,7 +1578,6 @@ class Boundary {
     } catch (error) {
       this.error(error);
     }
-    this.#pending = false;
   }
   #hydrate_pending_content() {
     const pending = this.#props.pending;
@@ -1655,13 +1601,13 @@ class Boundary {
             this.#pending_effect = null;
           }
         );
-        this.#pending = false;
+        this.is_pending = false;
       }
     });
   }
   #get_anchor() {
     var anchor = this.#anchor;
-    if (this.#pending) {
+    if (this.is_pending) {
       this.#pending_anchor = create_text();
       this.#anchor.before(this.#pending_anchor);
       anchor = this.#pending_anchor;
@@ -1669,11 +1615,18 @@ class Boundary {
     return anchor;
   }
   /**
-   * Returns `true` if the effect exists inside a boundary whose pending snippet is shown
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(effect) {
+    defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
+  }
+  /**
+   * Returns `false` if the effect exists inside a boundary whose pending snippet is shown
    * @returns {boolean}
    */
-  is_pending() {
-    return this.#pending || !!this.parent && this.parent.is_pending();
+  is_rendered() {
+    return !this.is_pending && (!this.parent || this.parent.is_rendered());
   }
   has_pending_snippet() {
     return !!this.#props.pending;
@@ -1730,7 +1683,17 @@ class Boundary {
     }
     this.#pending_count += d;
     if (this.#pending_count === 0) {
-      this.#pending = false;
+      this.is_pending = false;
+      for (const e of this.#dirty_effects) {
+        set_signal_status(e, DIRTY);
+        schedule_effect(e);
+      }
+      for (const e of this.#maybe_dirty_effects) {
+        set_signal_status(e, MAYBE_DIRTY);
+        schedule_effect(e);
+      }
+      this.#dirty_effects.clear();
+      this.#maybe_dirty_effects.clear();
       if (this.#pending_effect) {
         pause_effect(this.#pending_effect, () => {
           this.#pending_effect = null;
@@ -1807,7 +1770,7 @@ class Boundary {
           this.#failed_effect = null;
         });
       }
-      this.#pending = this.has_pending_snippet();
+      this.is_pending = this.has_pending_snippet();
       this.#main_effect = this.#run(() => {
         this.#is_creating_fallback = false;
         return branch(() => this.#children(this.#anchor));
@@ -1815,7 +1778,7 @@ class Boundary {
       if (this.#pending_count > 0) {
         this.#show_pending_snippet();
       } else {
-        this.#pending = false;
+        this.is_pending = false;
       }
     };
     var previous_reaction = active_reaction;
@@ -1900,10 +1863,14 @@ function execute_derived(derived) {
 function update_derived(derived) {
   var value = execute_derived(derived);
   if (!derived.equals(value)) {
-    if (!current_batch?.is_fork) {
+    derived.wv = increment_write_version();
+    if (!current_batch?.is_fork || derived.deps === null) {
       derived.v = value;
+      if (derived.deps === null) {
+        set_signal_status(derived, CLEAN);
+        return;
+      }
     }
-    derived.wv = increment_write_version();
   }
   if (is_destroying_effect) {
     return;
@@ -1913,8 +1880,7 @@ function update_derived(derived) {
       batch_values.set(derived, value);
     }
   } else {
-    var status = (derived.f & CONNECTED) === 0 ? MAYBE_DIRTY : CLEAN;
-    set_signal_status(derived, status);
+    update_derived_status(derived);
   }
 }
 let eager_effects = /* @__PURE__ */ new Set();
@@ -1967,13 +1933,14 @@ function internal_set(source2, value) {
     var batch = Batch.ensure();
     batch.capture(source2, old_value);
     if ((source2.f & DERIVED) !== 0) {
+      const derived = (
+        /** @type {Derived} */
+        source2
+      );
       if ((source2.f & DIRTY) !== 0) {
-        execute_derived(
-          /** @type {Derived} */
-          source2
-        );
+        execute_derived(derived);
       }
-      set_signal_status(source2, (source2.f & CONNECTED) !== 0 ? CLEAN : MAYBE_DIRTY);
+      update_derived_status(derived);
     }
     source2.wv = increment_write_version();
     mark_reactions(source2, DIRTY);
@@ -2581,23 +2548,24 @@ function is_dirty(reaction) {
     reaction.f &= ~WAS_MARKED;
   }
   if ((flags2 & MAYBE_DIRTY) !== 0) {
-    var dependencies = reaction.deps;
-    if (dependencies !== null) {
-      var length = dependencies.length;
-      for (var i = 0; i < length; i++) {
-        var dependency = dependencies[i];
-        if (is_dirty(
+    var dependencies = (
+      /** @type {Value[]} */
+      reaction.deps
+    );
+    var length = dependencies.length;
+    for (var i = 0; i < length; i++) {
+      var dependency = dependencies[i];
+      if (is_dirty(
+        /** @type {Derived} */
+        dependency
+      )) {
+        update_derived(
           /** @type {Derived} */
           dependency
-        )) {
-          update_derived(
-            /** @type {Derived} */
-            dependency
-          );
-        }
-        if (dependency.wv > reaction.wv) {
-          return true;
-        }
+        );
+      }
+      if (dependency.wv > reaction.wv) {
+        return true;
       }
     }
     if ((flags2 & CONNECTED) !== 0 && // During time traveling we don't want to reset the status so that
@@ -2701,6 +2669,16 @@ function update_reaction(reaction) {
     }
     if (previous_reaction !== null && previous_reaction !== reaction) {
       read_version++;
+      if (previous_reaction.deps !== null) {
+        for (let i2 = 0; i2 < previous_skipped_deps; i2 += 1) {
+          previous_reaction.deps[i2].rv = read_version;
+        }
+      }
+      if (previous_deps !== null) {
+        for (const dep of previous_deps) {
+          dep.rv = read_version;
+        }
+      }
       if (untracked_writes !== null) {
         if (previous_untracked_writes === null) {
           previous_untracked_writes = untracked_writes;
@@ -2746,20 +2724,17 @@ function remove_reaction(signal, dependency) {
   // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
   // allows us to skip the expensive work of disconnecting and immediately reconnecting it
   (new_deps === null || !new_deps.includes(dependency))) {
-    set_signal_status(dependency, MAYBE_DIRTY);
-    if ((dependency.f & CONNECTED) !== 0) {
-      dependency.f ^= CONNECTED;
-      dependency.f &= ~WAS_MARKED;
-    }
-    destroy_derived_effects(
-      /** @type {Derived} **/
+    var derived = (
+      /** @type {Derived} */
       dependency
     );
-    remove_reactions(
-      /** @type {Derived} **/
-      dependency,
-      0
-    );
+    if ((derived.f & CONNECTED) !== 0) {
+      derived.f ^= CONNECTED;
+      derived.f &= ~WAS_MARKED;
+    }
+    update_derived_status(derived);
+    destroy_derived_effects(derived);
+    remove_reactions(derived, 0);
   }
 }
 function remove_reactions(signal, start_index) {
@@ -2810,7 +2785,7 @@ function get(signal) {
             skipped_deps++;
           } else if (new_deps === null) {
             new_deps = [signal];
-          } else if (!new_deps.includes(signal)) {
+          } else {
             new_deps.push(signal);
           }
         }
@@ -2825,15 +2800,15 @@ function get(signal) {
       }
     }
   }
-  if (is_destroying_effect) {
-    if (old_values.has(signal)) {
-      return old_values.get(signal);
-    }
-    if (is_derived) {
-      var derived = (
-        /** @type {Derived} */
-        signal
-      );
+  if (is_destroying_effect && old_values.has(signal)) {
+    return old_values.get(signal);
+  }
+  if (is_derived) {
+    var derived = (
+      /** @type {Derived} */
+      signal
+    );
+    if (is_destroying_effect) {
       var value = derived.v;
       if ((derived.f & CLEAN) === 0 && derived.reactions !== null || depends_on_old_values(derived)) {
         value = execute_derived(derived);
@@ -2841,13 +2816,15 @@ function get(signal) {
       old_values.set(derived, value);
       return value;
     }
-  } else if (is_derived && (!batch_values?.has(signal) || current_batch?.is_fork && !effect_tracking())) {
-    derived = /** @type {Derived} */
-    signal;
+    var should_connect = (derived.f & CONNECTED) === 0 && !untracking && active_reaction !== null && (is_updating_effect || (active_reaction.f & CONNECTED) !== 0);
+    var is_new = derived.deps === null;
     if (is_dirty(derived)) {
+      if (should_connect) {
+        derived.f |= CONNECTED;
+      }
       update_derived(derived);
     }
-    if (is_updating_effect && effect_tracking() && (derived.f & CONNECTED) === 0) {
+    if (should_connect && !is_new) {
       reconnect(derived);
     }
   }
@@ -2861,7 +2838,7 @@ function get(signal) {
 }
 function reconnect(derived) {
   if (derived.deps === null) return;
-  derived.f ^= CONNECTED;
+  derived.f |= CONNECTED;
   for (const dep of derived.deps) {
     (dep.reactions ??= []).push(derived);
     if ((dep.f & DERIVED) !== 0 && (dep.f & CONNECTED) === 0) {
@@ -2897,10 +2874,6 @@ function untrack(fn) {
     untracking = previous_untracking;
   }
 }
-const STATUS_MASK = -7169;
-function set_signal_status(signal, status) {
-  signal.f = signal.f & STATUS_MASK | status;
-}
 const all_registered_events = /* @__PURE__ */ new Set();
 const root_event_handles = /* @__PURE__ */ new Set();
 let last_propagated_event = null;
@@ -3430,7 +3403,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: "107jfy4"
+  version_hash: "1l8s7jm"
 };
 async function get_hooks() {
   let handle;
@@ -3465,301 +3438,6 @@ const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
 const SVELTE_KIT_ASSETS = "/_svelte_kit_assets";
 const ENDPOINT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
 const PAGE_METHODS = ["GET", "POST", "HEAD"];
-const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
-const unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
-const reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
-function uneval(value, replacer) {
-  const counts = /* @__PURE__ */ new Map();
-  const keys = [];
-  const custom = /* @__PURE__ */ new Map();
-  function walk(thing) {
-    if (!is_primitive(thing)) {
-      if (counts.has(thing)) {
-        counts.set(thing, counts.get(thing) + 1);
-        return;
-      }
-      counts.set(thing, 1);
-      if (replacer) {
-        const str2 = replacer(thing, (value2) => uneval(value2, replacer));
-        if (typeof str2 === "string") {
-          custom.set(thing, str2);
-          return;
-        }
-      }
-      if (typeof thing === "function") {
-        throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-      }
-      const type = get_type(thing);
-      switch (type) {
-        case "Number":
-        case "BigInt":
-        case "String":
-        case "Boolean":
-        case "Date":
-        case "RegExp":
-        case "URL":
-        case "URLSearchParams":
-          return;
-        case "Array":
-          thing.forEach((value2, i) => {
-            keys.push(`[${i}]`);
-            walk(value2);
-            keys.pop();
-          });
-          break;
-        case "Set":
-          Array.from(thing).forEach(walk);
-          break;
-        case "Map":
-          for (const [key2, value2] of thing) {
-            keys.push(
-              `.get(${is_primitive(key2) ? stringify_primitive(key2) : "..."})`
-            );
-            walk(value2);
-            keys.pop();
-          }
-          break;
-        case "Int8Array":
-        case "Uint8Array":
-        case "Uint8ClampedArray":
-        case "Int16Array":
-        case "Uint16Array":
-        case "Int32Array":
-        case "Uint32Array":
-        case "Float32Array":
-        case "Float64Array":
-        case "BigInt64Array":
-        case "BigUint64Array":
-          walk(thing.buffer);
-          return;
-        case "ArrayBuffer":
-          return;
-        case "Temporal.Duration":
-        case "Temporal.Instant":
-        case "Temporal.PlainDate":
-        case "Temporal.PlainTime":
-        case "Temporal.PlainDateTime":
-        case "Temporal.PlainMonthDay":
-        case "Temporal.PlainYearMonth":
-        case "Temporal.ZonedDateTime":
-          return;
-        default:
-          if (!is_plain_object(thing)) {
-            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
-            );
-          }
-          for (const key2 in thing) {
-            keys.push(stringify_key(key2));
-            walk(thing[key2]);
-            keys.pop();
-          }
-      }
-    }
-  }
-  walk(value);
-  const names = /* @__PURE__ */ new Map();
-  Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
-    names.set(entry[0], get_name(i));
-  });
-  function stringify2(thing) {
-    if (names.has(thing)) {
-      return names.get(thing);
-    }
-    if (is_primitive(thing)) {
-      return stringify_primitive(thing);
-    }
-    if (custom.has(thing)) {
-      return custom.get(thing);
-    }
-    const type = get_type(thing);
-    switch (type) {
-      case "Number":
-      case "String":
-      case "Boolean":
-        return `Object(${stringify2(thing.valueOf())})`;
-      case "RegExp":
-        return `new RegExp(${stringify_string(thing.source)}, "${thing.flags}")`;
-      case "Date":
-        return `new Date(${thing.getTime()})`;
-      case "URL":
-        return `new URL(${stringify_string(thing.toString())})`;
-      case "URLSearchParams":
-        return `new URLSearchParams(${stringify_string(thing.toString())})`;
-      case "Array":
-        const members = (
-          /** @type {any[]} */
-          thing.map(
-            (v, i) => i in thing ? stringify2(v) : ""
-          )
-        );
-        const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
-        return `[${members.join(",")}${tail}]`;
-      case "Set":
-      case "Map":
-        return `new ${type}([${Array.from(thing).map(stringify2).join(",")}])`;
-      case "Int8Array":
-      case "Uint8Array":
-      case "Uint8ClampedArray":
-      case "Int16Array":
-      case "Uint16Array":
-      case "Int32Array":
-      case "Uint32Array":
-      case "Float32Array":
-      case "Float64Array":
-      case "BigInt64Array":
-      case "BigUint64Array": {
-        let str2 = `new ${type}`;
-        if (counts.get(thing.buffer) === 1) {
-          const array2 = new thing.constructor(thing.buffer);
-          str2 += `([${array2}])`;
-        } else {
-          str2 += `([${stringify2(thing.buffer)}])`;
-        }
-        const a = thing.byteOffset;
-        const b = a + thing.byteLength;
-        if (a > 0 || b !== thing.buffer.byteLength) {
-          const m = +/(\d+)/.exec(type)[1] / 8;
-          str2 += `.subarray(${a / m},${b / m})`;
-        }
-        return str2;
-      }
-      case "ArrayBuffer": {
-        const ui8 = new Uint8Array(thing);
-        return `new Uint8Array([${ui8.toString()}]).buffer`;
-      }
-      case "Temporal.Duration":
-      case "Temporal.Instant":
-      case "Temporal.PlainDate":
-      case "Temporal.PlainTime":
-      case "Temporal.PlainDateTime":
-      case "Temporal.PlainMonthDay":
-      case "Temporal.PlainYearMonth":
-      case "Temporal.ZonedDateTime":
-        return `${type}.from(${stringify_string(thing.toString())})`;
-      default:
-        const keys2 = Object.keys(thing);
-        const obj = keys2.map((key2) => `${safe_key(key2)}:${stringify2(thing[key2])}`).join(",");
-        const proto = Object.getPrototypeOf(thing);
-        if (proto === null) {
-          return keys2.length > 0 ? `{${obj},__proto__:null}` : `{__proto__:null}`;
-        }
-        return `{${obj}}`;
-    }
-  }
-  const str = stringify2(value);
-  if (names.size) {
-    const params = [];
-    const statements = [];
-    const values = [];
-    names.forEach((name, thing) => {
-      params.push(name);
-      if (custom.has(thing)) {
-        values.push(
-          /** @type {string} */
-          custom.get(thing)
-        );
-        return;
-      }
-      if (is_primitive(thing)) {
-        values.push(stringify_primitive(thing));
-        return;
-      }
-      const type = get_type(thing);
-      switch (type) {
-        case "Number":
-        case "String":
-        case "Boolean":
-          values.push(`Object(${stringify2(thing.valueOf())})`);
-          break;
-        case "RegExp":
-          values.push(thing.toString());
-          break;
-        case "Date":
-          values.push(`new Date(${thing.getTime()})`);
-          break;
-        case "Array":
-          values.push(`Array(${thing.length})`);
-          thing.forEach((v, i) => {
-            statements.push(`${name}[${i}]=${stringify2(v)}`);
-          });
-          break;
-        case "Set":
-          values.push(`new Set`);
-          statements.push(
-            `${name}.${Array.from(thing).map((v) => `add(${stringify2(v)})`).join(".")}`
-          );
-          break;
-        case "Map":
-          values.push(`new Map`);
-          statements.push(
-            `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify2(k)}, ${stringify2(v)})`).join(".")}`
-          );
-          break;
-        case "ArrayBuffer":
-          values.push(
-            `new Uint8Array([${new Uint8Array(thing).join(",")}]).buffer`
-          );
-          break;
-        default:
-          values.push(
-            Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}"
-          );
-          Object.keys(thing).forEach((key2) => {
-            statements.push(
-              `${name}${safe_prop(key2)}=${stringify2(thing[key2])}`
-            );
-          });
-      }
-    });
-    statements.push(`return ${str}`);
-    return `(function(${params.join(",")}){${statements.join(
-      ";"
-    )}}(${values.join(",")}))`;
-  } else {
-    return str;
-  }
-}
-function get_name(num) {
-  let name = "";
-  do {
-    name = chars[num % chars.length] + name;
-    num = ~~(num / chars.length) - 1;
-  } while (num >= 0);
-  return reserved.test(name) ? `${name}0` : name;
-}
-function escape_unsafe_char(c) {
-  return escaped[c] || c;
-}
-function escape_unsafe_chars(str) {
-  return str.replace(unsafe_chars, escape_unsafe_char);
-}
-function safe_key(key2) {
-  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key2) ? key2 : escape_unsafe_chars(JSON.stringify(key2));
-}
-function safe_prop(key2) {
-  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key2) ? `.${key2}` : `[${escape_unsafe_chars(JSON.stringify(key2))}]`;
-}
-function stringify_primitive(thing) {
-  if (typeof thing === "string") return stringify_string(thing);
-  if (thing === void 0) return "void 0";
-  if (thing === 0 && 1 / thing < 0) return "-0";
-  const str = String(thing);
-  if (typeof thing === "number") return str.replace(/^(-)?0\./, "$1.");
-  if (typeof thing === "bigint") return thing + "n";
-  return str;
-}
 function negotiate(accept, types) {
   const parts = [];
   accept.split(",").forEach((str, i) => {
@@ -6605,98 +6283,121 @@ function redirect_json_response(redirect) {
     }
   );
 }
-var cookie = {};
-var hasRequiredCookie;
-function requireCookie() {
-  if (hasRequiredCookie) return cookie;
-  hasRequiredCookie = 1;
-  cookie.parse = parse;
-  cookie.serialize = serialize;
-  var __toString = Object.prototype.toString;
-  var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
-  function parse(str, options2) {
-    if (typeof str !== "string") {
-      throw new TypeError("argument str must be a string");
-    }
-    var obj = {};
-    var opt = options2 || {};
-    var dec = opt.decode || decode;
-    var index = 0;
-    while (index < str.length) {
-      var eqIdx = str.indexOf("=", index);
-      if (eqIdx === -1) {
+var dist = {};
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  Object.defineProperty(dist, "__esModule", { value: true });
+  dist.parseCookie = parseCookie;
+  dist.parse = parseCookie;
+  dist.stringifyCookie = stringifyCookie;
+  dist.stringifySetCookie = stringifySetCookie;
+  dist.serialize = stringifySetCookie;
+  dist.parseSetCookie = parseSetCookie;
+  dist.stringifySetCookie = stringifySetCookie;
+  dist.serialize = stringifySetCookie;
+  const cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
+  const cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
+  const domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+  const pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+  const maxAgeRegExp = /^-?\d+$/;
+  const __toString = Object.prototype.toString;
+  const NullObject = /* @__PURE__ */ (() => {
+    const C = function() {
+    };
+    C.prototype = /* @__PURE__ */ Object.create(null);
+    return C;
+  })();
+  function parseCookie(str, options2) {
+    const obj = new NullObject();
+    const len = str.length;
+    if (len < 2)
+      return obj;
+    const dec = options2?.decode || decode;
+    let index = 0;
+    do {
+      const eqIdx = eqIndex(str, index, len);
+      if (eqIdx === -1)
         break;
-      }
-      var endIdx = str.indexOf(";", index);
-      if (endIdx === -1) {
-        endIdx = str.length;
-      } else if (endIdx < eqIdx) {
+      const endIdx = endIndex(str, index, len);
+      if (eqIdx > endIdx) {
         index = str.lastIndexOf(";", eqIdx - 1) + 1;
         continue;
       }
-      var key2 = str.slice(index, eqIdx).trim();
-      if (void 0 === obj[key2]) {
-        var val = str.slice(eqIdx + 1, endIdx).trim();
-        if (val.charCodeAt(0) === 34) {
-          val = val.slice(1, -1);
-        }
-        obj[key2] = tryDecode(val, dec);
+      const key2 = valueSlice(str, index, eqIdx);
+      if (obj[key2] === void 0) {
+        obj[key2] = dec(valueSlice(str, eqIdx + 1, endIdx));
       }
       index = endIdx + 1;
-    }
+    } while (index < len);
     return obj;
   }
-  function serialize(name, val, options2) {
-    var opt = options2 || {};
-    var enc = opt.encode || encode2;
-    if (typeof enc !== "function") {
-      throw new TypeError("option encode is invalid");
+  function stringifyCookie(cookie, options2) {
+    const enc = options2?.encode || encodeURIComponent;
+    const cookieStrings = [];
+    for (const name of Object.keys(cookie)) {
+      const val = cookie[name];
+      if (val === void 0)
+        continue;
+      if (!cookieNameRegExp.test(name)) {
+        throw new TypeError(`cookie name is invalid: ${name}`);
+      }
+      const value = enc(val);
+      if (!cookieValueRegExp.test(value)) {
+        throw new TypeError(`cookie val is invalid: ${val}`);
+      }
+      cookieStrings.push(`${name}=${value}`);
     }
-    if (!fieldContentRegExp.test(name)) {
-      throw new TypeError("argument name is invalid");
+    return cookieStrings.join("; ");
+  }
+  function stringifySetCookie(_name, _val, _opts) {
+    const cookie = typeof _name === "object" ? _name : { ..._opts, name: _name, value: String(_val) };
+    const options2 = typeof _val === "object" ? _val : _opts;
+    const enc = options2?.encode || encodeURIComponent;
+    if (!cookieNameRegExp.test(cookie.name)) {
+      throw new TypeError(`argument name is invalid: ${cookie.name}`);
     }
-    var value = enc(val);
-    if (value && !fieldContentRegExp.test(value)) {
-      throw new TypeError("argument val is invalid");
+    const value = cookie.value ? enc(cookie.value) : "";
+    if (!cookieValueRegExp.test(value)) {
+      throw new TypeError(`argument val is invalid: ${cookie.value}`);
     }
-    var str = name + "=" + value;
-    if (null != opt.maxAge) {
-      var maxAge = opt.maxAge - 0;
-      if (isNaN(maxAge) || !isFinite(maxAge)) {
-        throw new TypeError("option maxAge is invalid");
+    let str = cookie.name + "=" + value;
+    if (cookie.maxAge !== void 0) {
+      if (!Number.isInteger(cookie.maxAge)) {
+        throw new TypeError(`option maxAge is invalid: ${cookie.maxAge}`);
       }
-      str += "; Max-Age=" + Math.floor(maxAge);
+      str += "; Max-Age=" + cookie.maxAge;
     }
-    if (opt.domain) {
-      if (!fieldContentRegExp.test(opt.domain)) {
-        throw new TypeError("option domain is invalid");
+    if (cookie.domain) {
+      if (!domainValueRegExp.test(cookie.domain)) {
+        throw new TypeError(`option domain is invalid: ${cookie.domain}`);
       }
-      str += "; Domain=" + opt.domain;
+      str += "; Domain=" + cookie.domain;
     }
-    if (opt.path) {
-      if (!fieldContentRegExp.test(opt.path)) {
-        throw new TypeError("option path is invalid");
+    if (cookie.path) {
+      if (!pathValueRegExp.test(cookie.path)) {
+        throw new TypeError(`option path is invalid: ${cookie.path}`);
       }
-      str += "; Path=" + opt.path;
+      str += "; Path=" + cookie.path;
     }
-    if (opt.expires) {
-      var expires = opt.expires;
-      if (!isDate(expires) || isNaN(expires.valueOf())) {
-        throw new TypeError("option expires is invalid");
+    if (cookie.expires) {
+      if (!isDate(cookie.expires) || !Number.isFinite(cookie.expires.valueOf())) {
+        throw new TypeError(`option expires is invalid: ${cookie.expires}`);
       }
-      str += "; Expires=" + expires.toUTCString();
+      str += "; Expires=" + cookie.expires.toUTCString();
     }
-    if (opt.httpOnly) {
+    if (cookie.httpOnly) {
       str += "; HttpOnly";
     }
-    if (opt.secure) {
+    if (cookie.secure) {
       str += "; Secure";
     }
-    if (opt.partitioned) {
+    if (cookie.partitioned) {
       str += "; Partitioned";
     }
-    if (opt.priority) {
-      var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+    if (cookie.priority) {
+      const priority = typeof cookie.priority === "string" ? cookie.priority.toLowerCase() : void 0;
       switch (priority) {
         case "low":
           str += "; Priority=Low";
@@ -6708,49 +6409,130 @@ function requireCookie() {
           str += "; Priority=High";
           break;
         default:
-          throw new TypeError("option priority is invalid");
+          throw new TypeError(`option priority is invalid: ${cookie.priority}`);
       }
     }
-    if (opt.sameSite) {
-      var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+    if (cookie.sameSite) {
+      const sameSite = typeof cookie.sameSite === "string" ? cookie.sameSite.toLowerCase() : cookie.sameSite;
       switch (sameSite) {
         case true:
+        case "strict":
           str += "; SameSite=Strict";
           break;
         case "lax":
           str += "; SameSite=Lax";
           break;
-        case "strict":
-          str += "; SameSite=Strict";
-          break;
         case "none":
           str += "; SameSite=None";
           break;
         default:
-          throw new TypeError("option sameSite is invalid");
+          throw new TypeError(`option sameSite is invalid: ${cookie.sameSite}`);
       }
     }
     return str;
   }
-  function decode(str) {
-    return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+  function parseSetCookie(str, options2) {
+    const dec = options2?.decode || decode;
+    const len = str.length;
+    const endIdx = endIndex(str, 0, len);
+    const eqIdx = eqIndex(str, 0, endIdx);
+    const setCookie2 = eqIdx === -1 ? { name: "", value: dec(valueSlice(str, 0, endIdx)) } : {
+      name: valueSlice(str, 0, eqIdx),
+      value: dec(valueSlice(str, eqIdx + 1, endIdx))
+    };
+    let index = endIdx + 1;
+    while (index < len) {
+      const endIdx2 = endIndex(str, index, len);
+      const eqIdx2 = eqIndex(str, index, endIdx2);
+      const attr = eqIdx2 === -1 ? valueSlice(str, index, endIdx2) : valueSlice(str, index, eqIdx2);
+      const val = eqIdx2 === -1 ? void 0 : valueSlice(str, eqIdx2 + 1, endIdx2);
+      switch (attr.toLowerCase()) {
+        case "httponly":
+          setCookie2.httpOnly = true;
+          break;
+        case "secure":
+          setCookie2.secure = true;
+          break;
+        case "partitioned":
+          setCookie2.partitioned = true;
+          break;
+        case "domain":
+          setCookie2.domain = val;
+          break;
+        case "path":
+          setCookie2.path = val;
+          break;
+        case "max-age":
+          if (val && maxAgeRegExp.test(val))
+            setCookie2.maxAge = Number(val);
+          break;
+        case "expires":
+          if (!val)
+            break;
+          const date = new Date(val);
+          if (Number.isFinite(date.valueOf()))
+            setCookie2.expires = date;
+          break;
+        case "priority":
+          if (!val)
+            break;
+          const priority = val.toLowerCase();
+          if (priority === "low" || priority === "medium" || priority === "high") {
+            setCookie2.priority = priority;
+          }
+          break;
+        case "samesite":
+          if (!val)
+            break;
+          const sameSite = val.toLowerCase();
+          if (sameSite === "lax" || sameSite === "strict" || sameSite === "none") {
+            setCookie2.sameSite = sameSite;
+          }
+          break;
+      }
+      index = endIdx2 + 1;
+    }
+    return setCookie2;
   }
-  function encode2(val) {
-    return encodeURIComponent(val);
+  function endIndex(str, min, len) {
+    const index = str.indexOf(";", min);
+    return index === -1 ? len : index;
   }
-  function isDate(val) {
-    return __toString.call(val) === "[object Date]" || val instanceof Date;
+  function eqIndex(str, min, max) {
+    const index = str.indexOf("=", min);
+    return index < max ? index : -1;
   }
-  function tryDecode(str, decode2) {
+  function valueSlice(str, min, max) {
+    let start = min;
+    let end = max;
+    do {
+      const code = str.charCodeAt(start);
+      if (code !== 32 && code !== 9)
+        break;
+    } while (++start < end);
+    while (end > start) {
+      const code = str.charCodeAt(end - 1);
+      if (code !== 32 && code !== 9)
+        break;
+      end--;
+    }
+    return str.slice(start, end);
+  }
+  function decode(str) {
+    if (str.indexOf("%") === -1)
+      return str;
     try {
-      return decode2(str);
+      return decodeURIComponent(str);
     } catch (e) {
       return str;
     }
   }
-  return cookie;
+  function isDate(val) {
+    return __toString.call(val) === "[object Date]";
+  }
+  return dist;
 }
-var cookieExports = requireCookie();
+var distExports = /* @__PURE__ */ requireDist();
 const INVALID_COOKIE_CHARACTER_REGEX = /[\x00-\x1F\x7F()<>@,;:"/[\]?={} \t]/;
 function validate_options(options2) {
   if (options2?.path === void 0) {
@@ -6762,7 +6544,7 @@ function generate_cookie_key(domain, path, name) {
 }
 function get_cookies(request, url) {
   const header = request.headers.get("cookie") ?? "";
-  const initial_cookies = cookieExports.parse(header, { decode: (value) => value });
+  const initial_cookies = distExports.parse(header, { decode: (value) => value });
   let normalized_url;
   const new_cookies = /* @__PURE__ */ new Map();
   const defaults = {
@@ -6786,15 +6568,15 @@ function get_cookies(request, url) {
       if (best_match) {
         return best_match.options.maxAge === 0 ? void 0 : best_match.value;
       }
-      const req_cookies = cookieExports.parse(header, { decode: opts?.decode });
-      const cookie2 = req_cookies[name];
-      return cookie2;
+      const req_cookies = distExports.parse(header, { decode: opts?.decode });
+      const cookie = req_cookies[name];
+      return cookie;
     },
     /**
      * @param {import('cookie').CookieParseOptions} [opts]
      */
     getAll(opts) {
-      const cookies2 = cookieExports.parse(header, { decode: opts?.decode });
+      const cookies2 = distExports.parse(header, { decode: opts?.decode });
       const lookup = /* @__PURE__ */ new Map();
       for (const c of new_cookies.values()) {
         if (domain_matches(url.hostname, c.options.domain) && path_matches(url.pathname, c.options.path)) {
@@ -6848,7 +6630,7 @@ function get_cookies(request, url) {
         }
         path = resolve(normalized_url, path);
       }
-      return cookieExports.serialize(name, value, { ...defaults, ...options2, path });
+      return distExports.serialize(name, value, { ...defaults, ...options2, path });
     }
   };
   function get_cookie_header(destination, header2) {
@@ -6856,14 +6638,14 @@ function get_cookies(request, url) {
       // cookies sent by the user agent have lowest precedence
       ...initial_cookies
     };
-    for (const cookie2 of new_cookies.values()) {
-      if (!domain_matches(destination.hostname, cookie2.options.domain)) continue;
-      if (!path_matches(destination.pathname, cookie2.options.path)) continue;
-      const encoder = cookie2.options.encode || encodeURIComponent;
-      combined_cookies[cookie2.name] = encoder(cookie2.value);
+    for (const cookie of new_cookies.values()) {
+      if (!domain_matches(destination.hostname, cookie.options.domain)) continue;
+      if (!path_matches(destination.pathname, cookie.options.path)) continue;
+      const encoder = cookie.options.encode || encodeURIComponent;
+      combined_cookies[cookie.name] = encoder(cookie.value);
     }
     if (header2) {
-      const parsed = cookieExports.parse(header2, { decode: (value) => value });
+      const parsed = distExports.parse(header2, { decode: (value) => value });
       for (const name in parsed) {
         combined_cookies[name] = parsed[name];
       }
@@ -6881,8 +6663,8 @@ function get_cookies(request, url) {
       path = resolve(normalized_url, path);
     }
     const cookie_key = generate_cookie_key(options2.domain, path, name);
-    const cookie2 = { name, value, options: { ...options2, path } };
-    new_cookies.set(cookie_key, cookie2);
+    const cookie = { name, value, options: { ...options2, path } };
+    new_cookies.set(cookie_key, cookie);
   }
   function set_trailing_slash(trailing_slash) {
     normalized_url = normalize_path(url.pathname, trailing_slash);
@@ -6905,10 +6687,10 @@ function path_matches(path, constraint) {
 function add_cookies_to_headers(headers2, cookies) {
   for (const new_cookie of cookies) {
     const { name, value, options: options2 } = new_cookie;
-    headers2.append("set-cookie", cookieExports.serialize(name, value, options2));
+    headers2.append("set-cookie", distExports.serialize(name, value, options2));
     if (options2.path.endsWith(".html")) {
       const path = add_data_suffix(options2.path);
-      headers2.append("set-cookie", cookieExports.serialize(name, value, { ...options2, path }));
+      headers2.append("set-cookie", distExports.serialize(name, value, { ...options2, path }));
     }
   }
 }
@@ -6949,9 +6731,9 @@ function requireSetCookie() {
         e
       );
     }
-    var cookie2 = createNullObj();
-    cookie2.name = name;
-    cookie2.value = value;
+    var cookie = createNullObj();
+    cookie.name = name;
+    cookie.value = value;
     parts.forEach(function(part) {
       var sides = part.split("=");
       var key2 = sides.shift().trimLeft().toLowerCase();
@@ -6960,23 +6742,23 @@ function requireSetCookie() {
       }
       var value2 = sides.join("=");
       if (key2 === "expires") {
-        cookie2.expires = new Date(value2);
+        cookie.expires = new Date(value2);
       } else if (key2 === "max-age") {
         var n = parseInt(value2, 10);
-        if (!Number.isNaN(n)) cookie2.maxAge = n;
+        if (!Number.isNaN(n)) cookie.maxAge = n;
       } else if (key2 === "secure") {
-        cookie2.secure = true;
+        cookie.secure = true;
       } else if (key2 === "httponly") {
-        cookie2.httpOnly = true;
+        cookie.httpOnly = true;
       } else if (key2 === "samesite") {
-        cookie2.sameSite = value2;
+        cookie.sameSite = value2;
       } else if (key2 === "partitioned") {
-        cookie2.partitioned = true;
+        cookie.partitioned = true;
       } else if (key2) {
-        cookie2[key2] = value2;
+        cookie[key2] = value2;
       }
     });
-    return cookie2;
+    return cookie;
   }
   function parseNameValuePair(nameValuePairStr) {
     var name = "";
@@ -7026,9 +6808,9 @@ function requireSetCookie() {
     } else {
       var cookies = createNullObj();
       return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
-        var cookie2 = parseString(str, options2);
-        if (cookie2 && !isForbiddenKey(cookie2.name)) {
-          cookies2[cookie2.name] = cookie2;
+        var cookie = parseString(str, options2);
+        if (cookie && !isForbiddenKey(cookie.name)) {
+          cookies2[cookie.name] = cookie;
         }
         return cookies2;
       }, cookies);
@@ -7119,8 +6901,8 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
         }
         if (url.origin !== event.url.origin) {
           if (`.${url.hostname}`.endsWith(`.${event.url.hostname}`) && credentials !== "omit") {
-            const cookie2 = get_cookie_header(url, request.headers.get("cookie"));
-            if (cookie2) request.headers.set("cookie", cookie2);
+            const cookie = get_cookie_header(url, request.headers.get("cookie"));
+            if (cookie) request.headers.set("cookie", cookie);
           }
           return fetch(request);
         }
@@ -7153,9 +6935,9 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
           return await fetch(request);
         }
         if (credentials !== "omit") {
-          const cookie2 = get_cookie_header(url, request.headers.get("cookie"));
-          if (cookie2) {
-            request.headers.set("cookie", cookie2);
+          const cookie = get_cookie_header(url, request.headers.get("cookie"));
+          if (cookie) {
+            request.headers.set("cookie", cookie);
           }
           const authorization = event.request.headers.get("authorization");
           if (authorization && !request.headers.has("authorization")) {
@@ -7384,20 +7166,27 @@ async function internal_respond(request, options2, manifest, state) {
   } catch {
     return text("Malformed URI", { status: 400 });
   }
-  if (resolved_path !== url.pathname && !state.prerendering?.fallback && has_prerendered_path(manifest, resolved_path)) {
+  if (
+    // the resolved path has been decoded so it should be compared to the decoded url pathname
+    resolved_path !== decode_pathname(url.pathname) && !state.prerendering?.fallback && has_prerendered_path(manifest, resolved_path)
+  ) {
     const url2 = new URL(request.url);
     url2.pathname = is_data_request ? add_data_suffix(resolved_path) : is_route_resolution_request ? add_resolution_suffix(resolved_path) : resolved_path;
-    const response = await fetch(url2, request);
-    const headers22 = new Headers(response.headers);
-    if (headers22.has("content-encoding")) {
-      headers22.delete("content-encoding");
-      headers22.delete("content-length");
-    }
-    return new Response(response.body, {
-      headers: headers22,
-      status: response.status,
-      statusText: response.statusText
-    });
+    try {
+      const response = await fetch(url2, request);
+      const headers22 = new Headers(response.headers);
+      if (headers22.has("content-encoding")) {
+        headers22.delete("content-encoding");
+        headers22.delete("content-length");
+      }
+      return new Response(response.body, {
+        headers: headers22,
+        status: response.status,
+        statusText: response.statusText
+      });
+    } catch (error2) {
+      return await handle_fatal_error(event, event_state, options2, error2);
+    }
   }
   let route = null;
   if (base && !state.prerendering?.fallback) {