@claude-sessions/web 0.3.7 → 0.4.1-beta.0

package/build/server/index.js

@@ -1,7 +1,8 @@
-import { s as set, L as LEGACY_PROPS, g as get, f as flushSync, d as define_property, m as mutable_source, i as init_operations, a as get_first_child, C as COMMENT_NODE, H as HYDRATION_START, b as get_next_sibling, c as HYDRATION_ERROR, h as hydration_failed, e as clear_text_content, j as array_from, k as component_root, l as set_active_reaction, n as set_active_effect, o as active_effect, p as active_reaction, q as create_text, r as setContext, t as block, u as branch, B as Batch, v as pause_effect, w as set_component_context, x as handle_error, y as component_context, z as move_effect, A as internal_set, D as destroy_effect, E as invoke_error_boundary, F as queue_micro_task, G as svelte_boundary_reset_onerror, I as effect_tracking, J as source, K as render_effect, M as HYDRATION_END, N as HYDRATION_START_ELSE, O as untrack, P as increment, Q as push$1, R as pop$1, S as EFFECT_TRANSPARENT, T as EFFECT_PRESERVED, U as BOUNDARY_EFFECT, V as BROWSER, W as readable, X as writable } from './chunks/index-DzYX9r1_.js';
-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 set, L as LEGACY_PROPS, g as get, f as flushSync, d as define_property, m as mutable_source, i as init_operations, a as get_first_child, C as COMMENT_NODE, H as HYDRATION_START, b as get_next_sibling, c as HYDRATION_ERROR, h as hydration_failed, e as clear_text_content, j as array_from, k as component_root, l as set_active_reaction, n as set_active_effect, o as active_effect, p as active_reaction, q as create_text, r as setContext, t as block, u as branch, B as Batch, v as pause_effect, w as defer_effect, x as set_component_context, y as handle_error, z as component_context, A as move_effect, D as set_signal_status, E as DIRTY, F as schedule_effect, M as MAYBE_DIRTY, G as internal_set, I as destroy_effect, J as invoke_error_boundary, K as queue_micro_task, N as svelte_boundary_reset_onerror, O as effect_tracking, P as source, Q as render_effect, R as HYDRATION_END, S as HYDRATION_START_ELSE, T as untrack, U as increment, V as push$1, W as pop$1, X as EFFECT_TRANSPARENT, Y as EFFECT_PRESERVED, Z as BOUNDARY_EFFECT, _ as BROWSER, $ as readable, a0 as writable } from './chunks/index2-ybZwlzIk.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 { t as text_decoder, b as base64_decode, d as decode_pathname, a as decode_params, n as normalize_path, c as disable_search, w as with_request_store, v as validate_layout_server_exports, e as validate_layout_exports, f as validate_page_server_exports, g as validate_page_exports, h as text_encoder, r as resolve, m as make_trackable, i as get_relative_path, j as base64_encode } from './chunks/exports-BXvEiaiv.js';
-import { r as render, i as is_passive_event } from './chunks/index2-Da0doXJY.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, c as is_passive_event, u as uneval } from './chunks/index-BEaiIYry.js';
+import { s as set_private_env, a as set_public_env, p as public_env } from './chunks/shared-server-DaWdgxVh.js';
 
 /**
  * @template {{ tracing: { enabled: boolean, root: import('@opentelemetry/api').Span, current: import('@opentelemetry/api').Span } }} T
@@ -33,94 +34,6 @@ function reset() {
   assets = initial.assets;
 }
 
-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 = "";
@@ -210,6 +123,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;
@@ -232,7 +146,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":
@@ -279,13 +200,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;
@@ -371,14 +299,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}]`;
@@ -422,7 +350,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();
@@ -513,7 +441,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());
@@ -560,17 +488,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) {
@@ -596,8 +529,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++;
@@ -606,35 +538,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,
@@ -661,6 +605,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;
@@ -755,7 +702,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;
         }
@@ -827,12 +774,6 @@ function create_remote_key(id, payload) {
   return id + "/" + payload;
 }
 
-let public_env = {};
-function set_private_env(environment) {
-}
-function set_public_env(environment) {
-  public_env = environment;
-}
 function hydration_mismatch(location) {
   {
     console.warn(`https://svelte.dev/e/hydration_mismatch`);
@@ -926,7 +867,7 @@ function boundary(node, props, children) {
 class Boundary {
   /** @type {Boundary | null} */
   parent;
-  #pending = false;
+  is_pending = false;
   /** @type {TemplateNode} */
   #anchor;
   /** @type {TemplateNode | null} */
@@ -950,6 +891,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,
@@ -975,7 +920,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) {
@@ -990,6 +935,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();
@@ -1001,7 +949,7 @@ class Boundary {
         if (this.#pending_count > 0) {
           this.#show_pending_snippet();
         } else {
-          this.#pending = false;
+          this.is_pending = false;
         }
       }
       return () => {
@@ -1018,7 +966,6 @@ class Boundary {
     } catch (error) {
       this.error(error);
     }
-    this.#pending = false;
   }
   #hydrate_pending_content() {
     const pending = this.#props.pending;
@@ -1042,13 +989,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;
@@ -1056,11 +1003,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;
@@ -1117,7 +1071,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;
@@ -1194,7 +1158,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));
@@ -1202,7 +1166,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;
@@ -1782,7 +1746,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: "1ynyipk"
+  version_hash: "13pr0l3"
 };
 async function get_hooks() {
   let handle;
@@ -1817,301 +1781,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) => {
@@ -5773,20 +5442,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) {