bloko-studio 0.0.17 → 0.0.19

package/dist/server/index.js

@@ -1,12 +1,13 @@
-import { r as render, g as set, L as LEGACY_PROPS, h as get, i as flushSync, m as mutable_source, j as init_operations, k as get_first_child, C as COMMENT_NODE, H as HYDRATION_START, l as get_next_sibling, n as HYDRATION_ERROR, o as hydration_failed, p as clear_text_content, q as component_root, t as is_passive_event, v as set_active_reaction, w as set_active_effect, x as active_effect, y as active_reaction, z as create_text, A as internal_set, B as block, D as branch, E as Batch, F as pause_effect, G as set_component_context, I as handle_error, J as component_context, K as queue_micro_task, M as effect_pending_updates, N as destroy_effect, O as invoke_error_boundary, P as svelte_boundary_reset_onerror, Q as effect_tracking, R as source, S as render_effect, T as HYDRATION_END, U as HYDRATION_START_ELSE, V as untrack, W as increment, X as push, Y as pop, Z as EFFECT_TRANSPARENT, _ as EFFECT_PRESERVED, $ as BOUNDARY_EFFECT, a0 as DEV } from './chunks/index2-B25TYUvp.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-Djsj11qr.js';
-import { w as with_request_store, c as text_encoder, d as get_relative_path, a as base64_encode, t as text_decoder } from './chunks/utils-UnnCNxc8.js';
-import { d as decode_pathname, a as decode_params, n as normalize_path, b as disable_search, v as validate_layout_server_exports, c as validate_layout_exports, e as validate_page_server_exports, f as validate_page_exports, r as resolve, m as make_trackable } from './chunks/exports-Cv9LZeD1.js';
-import { r as readable, w as writable } from './chunks/index-ku2qcDDa.js';
-import { e as define_property, h as array_from, c as is_array } from './chunks/utils2-CMYnPZWH.js';
+import { r as render, g as set, L as LEGACY_PROPS, h as get, i as flushSync, m as mutable_source, j as init_operations, k as get_first_child, C as COMMENT_NODE, H as HYDRATION_START, l as get_next_sibling, n as HYDRATION_ERROR, o as hydration_failed, p as clear_text_content, q as component_root, t as set_active_reaction, v as set_active_effect, w as active_effect, x as active_reaction, y as is_passive_event, z as create_text, A as block, B as branch, D as queue_micro_task, E as Batch, F as pause_effect, G as defer_effect, I as set_component_context, J as handle_error, K as component_context, M as move_effect, N as set_signal_status, O as DIRTY, P as schedule_effect, Q as MAYBE_DIRTY, R as internal_set, S as destroy_effect, T as invoke_error_boundary, U as svelte_boundary_reset_onerror, V as effect_tracking, W as render_effect, X as HYDRATION_END, Y as source, Z as HYDRATION_START_ELSE, _ as untrack, $ as increment, a0 as push, a1 as pop, a2 as EFFECT_TRANSPARENT, a3 as EFFECT_PRESERVED, a4 as BOUNDARY_EFFECT, a5 as DEV, a6 as uneval } from './chunks/index2-CX4O5PGD.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-wpIsICWW.js';
+import { t as text_decoder, w as with_request_store, c as text_encoder, d as get_relative_path, a as base64_encode } from './chunks/utils-UnnCNxc8.js';
+import { p as parse, T as TRAILING_SLASH_PARAM, I as INVALIDATED_PARAM, c as create_remote_key, a as parse_remote_arg, b as stringify, d as stringify$1 } from './chunks/shared-ivl7CnzJ.js';
+import { d as decode_pathname, a as decode_params, n as normalize_path, b as disable_search, v as validate_layout_server_exports, c as validate_layout_exports, e as validate_page_server_exports, f as validate_page_exports, r as resolve, m as make_trackable } from './chunks/exports-CtTNDGe5.js';
+import { r as readable, w as writable } from './chunks/index-BqiKLn9N.js';
+import { h as define_property, j as array_from } from './chunks/utils2-CiEO2gKG.js';
 import { a as setContext } from './chunks/context-H6NpHtt-.js';
-import { i as is_primitive, g as get_type, D as DevalueError, a as is_plain_object, e as enumerable_symbols, b as stringify_key, d as stringify_string, f as escaped, T as TRAILING_SLASH_PARAM, I as INVALIDATED_PARAM, c as create_remote_cache_key, p as parse_remote_arg, h as stringify, j as stringify$1 } from './chunks/shared-CAxGHzOK.js';
 import './chunks/escaping-CqgfEcN3.js';
+import './chunks/utils-CmmEjlra.js';
 
 /**
  * @template {{ tracing: { enabled: boolean, root: import('@opentelemetry/api').Span, current: import('@opentelemetry/api').Span } }} T
@@ -38,397 +39,310 @@ function reset() {
   assets = initial.assets;
 }
 
-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)$/;
-
-/**
- * Turn a value into the JavaScript that creates an equivalent value
- * @param {any} value
- * @param {(value: any, uneval: (value: any) => string) => string | void} [replacer]
- */
-function uneval(value, replacer) {
-	const counts = new Map();
-
-	/** @type {string[]} */
-	const keys = [];
-
-	const custom = new Map();
-
-	/** @param {any} thing */
-	function walk(thing) {
-		if (typeof thing === 'function') {
-			throw new DevalueError(`Cannot stringify a function`, keys);
-		}
-
-		if (!is_primitive(thing)) {
-			if (counts.has(thing)) {
-				counts.set(thing, counts.get(thing) + 1);
-				return;
-			}
-
-			counts.set(thing, 1);
-
-			if (replacer) {
-				const str = replacer(thing, (value) => uneval(value, replacer));
-
-				if (typeof str === 'string') {
-					custom.set(thing, str);
-					return;
-				}
-			}
-
-			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':
-					/** @type {any[]} */ (thing).forEach((value, i) => {
-						keys.push(`[${i}]`);
-						walk(value);
-						keys.pop();
-					});
-					break;
-
-				case 'Set':
-					Array.from(thing).forEach(walk);
-					break;
-
-				case 'Map':
-					for (const [key, value] of thing) {
-						keys.push(
-							`.get(${is_primitive(key) ? stringify_primitive(key) : '...'})`
-						);
-						walk(value);
-						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
-						);
-					}
-
-					if (enumerable_symbols(thing).length > 0) {
-						throw new DevalueError(
-							`Cannot stringify POJOs with symbolic keys`,
-							keys
-						);
-					}
-
-					for (const key in thing) {
-						keys.push(stringify_key(key));
-						walk(thing[key]);
-						keys.pop();
-					}
-			}
-		}
-	}
-
-	walk(value);
-
-	const names = 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));
-		});
-
-	/**
-	 * @param {any} thing
-	 * @returns {string}
-	 */
-	function stringify(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(${stringify(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 ? stringify(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(stringify).join(',')}])`;
-
-			case 'Int8Array':
-			case 'Uint8Array':
-			case 'Uint8ClampedArray':
-			case 'Int16Array':
-			case 'Uint16Array':
-			case 'Int32Array':
-			case 'Uint32Array':
-			case 'Float32Array':
-			case 'Float64Array':
-			case 'BigInt64Array':
-			case 'BigUint64Array': {
-				let str = `new ${type}`;
-
-				if (counts.get(thing.buffer) === 1) {
-					const array = new thing.constructor(thing.buffer);
-					str += `([${array}])`;
-				} else {
-					str += `([${stringify(thing.buffer)}])`;
-				}
-
-				const a = thing.byteOffset;
-				const b = a + thing.byteLength;
-
-				// handle subarrays
-				if (a > 0 || b !== thing.buffer.byteLength) {
-					const m = +/(\d+)/.exec(type)[1] / 8;
-					str += `.subarray(${a / m},${b / m})`;
-				}
-
-				return str;
-			}
-
-			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 keys = Object.keys(thing);
-				const obj = keys
-					.map((key) => `${safe_key(key)}:${stringify(thing[key])}`)
-					.join(',');
-				const proto = Object.getPrototypeOf(thing);
-				if (proto === null) {
-					return keys.length > 0
-						? `{${obj},__proto__:null}`
-						: `{__proto__:null}`;
-				}
-
-				return `{${obj}}`;
-		}
-	}
-
-	const str = stringify(value);
-
-	if (names.size) {
-		/** @type {string[]} */
-		const params = [];
-
-		/** @type {string[]} */
-		const statements = [];
-
-		/** @type {string[]} */
-		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(${stringify(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})`);
-					/** @type {any[]} */ (thing).forEach((v, i) => {
-						statements.push(`${name}[${i}]=${stringify(v)}`);
-					});
-					break;
-
-				case 'Set':
-					values.push(`new Set`);
-					statements.push(
-						`${name}.${Array.from(thing)
-							.map((v) => `add(${stringify(v)})`)
-							.join('.')}`
-					);
-					break;
-
-				case 'Map':
-					values.push(`new Map`);
-					statements.push(
-						`${name}.${Array.from(thing)
-							.map(([k, v]) => `set(${stringify(k)}, ${stringify(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((key) => {
-						statements.push(
-							`${name}${safe_prop(key)}=${stringify(thing[key])}`
-						);
-					});
-			}
-		});
-
-		statements.push(`return ${str}`);
-
-		return `(function(${params.join(',')}){${statements.join(
-			';'
-		)}}(${values.join(',')}))`;
-	} else {
-		return str;
-	}
-}
-
-/** @param {number} num */
-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 set_nested_value(object, path_string, value) {
+  if (path_string.startsWith("n:")) {
+    path_string = path_string.slice(2);
+    value = value === "" ? void 0 : parseFloat(value);
+  } else if (path_string.startsWith("b:")) {
+    path_string = path_string.slice(2);
+    value = value === "on";
+  }
+  deep_set(object, split_path(path_string), value);
 }
-
-/** @param {string} c */
-function escape_unsafe_char(c) {
-	return escaped[c] || c;
+function convert_formdata(data) {
+  const result = {};
+  for (let key of data.keys()) {
+    const is_array = key.endsWith("[]");
+    let values = data.getAll(key);
+    if (is_array) key = key.slice(0, -2);
+    if (values.length > 1 && !is_array) {
+      throw new Error(`Form cannot contain duplicated keys — "${key}" has ${values.length} values`);
+    }
+    values = values.filter(
+      (entry) => typeof entry === "string" || entry.name !== "" || entry.size > 0
+    );
+    if (key.startsWith("n:")) {
+      key = key.slice(2);
+      values = values.map((v) => v === "" ? void 0 : parseFloat(
+        /** @type {string} */
+        v
+      ));
+    } else if (key.startsWith("b:")) {
+      key = key.slice(2);
+      values = values.map((v) => v === "on");
+    }
+    set_nested_value(result, key, is_array ? values : values[0]);
+  }
+  return result;
 }
-
-/** @param {string} str */
-function escape_unsafe_chars(str) {
-	return str.replace(unsafe_chars, escape_unsafe_char);
+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 deserialize_error("no body");
+  }
+  const content_length = parseInt(request.headers.get("content-length") ?? "");
+  if (Number.isNaN(content_length)) {
+    throw deserialize_error("invalid Content-Length header");
+  }
+  const reader = request.body.getReader();
+  const chunks = [];
+  function get_chunk(index) {
+    if (index in chunks) return chunks[index];
+    let i = chunks.length;
+    while (i <= index) {
+      chunks[i] = reader.read().then((chunk) => chunk.value);
+      i++;
+    }
+    return chunks[index];
+  }
+  async function get_buffer(offset, length) {
+    let start_chunk;
+    let chunk_start = 0;
+    let chunk_index;
+    for (chunk_index = 0; ; chunk_index++) {
+      const chunk = await get_chunk(chunk_index);
+      if (!chunk) return null;
+      const chunk_end = chunk_start + chunk.byteLength;
+      if (offset >= chunk_start && offset < chunk_end) {
+        start_chunk = chunk;
+        break;
+      }
+      chunk_start = chunk_end;
+    }
+    if (offset + length <= chunk_start + start_chunk.byteLength) {
+      return start_chunk.subarray(offset - chunk_start, offset + length - chunk_start);
+    }
+    const chunks2 = [start_chunk.subarray(offset - chunk_start)];
+    let cursor = start_chunk.byteLength - offset + chunk_start;
+    while (cursor < length) {
+      chunk_index++;
+      let chunk = await get_chunk(chunk_index);
+      if (!chunk) return null;
+      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, HEADER_BYTES);
+  if (!header) throw deserialize_error("too short");
+  if (header[0] !== 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);
+  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(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 = 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,
+          type,
+          size,
+          last_modified,
+          get_chunk,
+          files_start_offset + file_offsets[index]
+        ),
+        {
+          getPrototypeOf() {
+            return File.prototype;
+          }
+        }
+      );
+    }
+  });
+  void (async () => {
+    let has_more = true;
+    while (has_more) {
+      const chunk = await get_chunk(chunks.length);
+      has_more = !!chunk;
+    }
+  })();
+  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;
+  /** @type {number} */
+  #offset;
+  /**
+   * @param {string} name
+   * @param {string} type
+   * @param {number} size
+   * @param {number} last_modified
+   * @param {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} get_chunk
+   * @param {number} offset
+   */
+  constructor(name, type, size, last_modified, get_chunk, offset) {
+    this.name = name;
+    this.type = type;
+    this.size = size;
+    this.lastModified = last_modified;
+    this.webkitRelativePath = "";
+    this.#get_chunk = get_chunk;
+    this.#offset = offset;
+    this.arrayBuffer = this.arrayBuffer.bind(this);
+    this.bytes = this.bytes.bind(this);
+    this.slice = this.slice.bind(this);
+    this.stream = this.stream.bind(this);
+    this.text = this.text.bind(this);
+  }
+  /** @type {ArrayBuffer | undefined} */
+  #buffer;
+  async arrayBuffer() {
+    this.#buffer ??= await new Response(this.stream()).arrayBuffer();
+    return this.#buffer;
+  }
+  async bytes() {
+    return new Uint8Array(await this.arrayBuffer());
+  }
+  /**
+   * @param {number=} start
+   * @param {number=} end
+   * @param {string=} contentType
+   */
+  slice(start = 0, end = this.size, contentType = this.type) {
+    if (start < 0) {
+      start = Math.max(this.size + start, 0);
+    } else {
+      start = Math.min(start, this.size);
+    }
+    if (end < 0) {
+      end = Math.max(this.size + end, 0);
+    } else {
+      end = Math.min(end, this.size);
+    }
+    const size = Math.max(end - start, 0);
+    const file = new LazyFile(
+      this.name,
+      contentType,
+      size,
+      this.lastModified,
+      this.#get_chunk,
+      this.#offset + start
+    );
+    return file;
+  }
+  stream() {
+    let cursor = 0;
+    let chunk_index = 0;
+    return new ReadableStream({
+      start: async (controller) => {
+        let chunk_start = 0;
+        let start_chunk = null;
+        for (chunk_index = 0; ; chunk_index++) {
+          const chunk = await this.#get_chunk(chunk_index);
+          if (!chunk) return null;
+          const chunk_end = chunk_start + chunk.byteLength;
+          if (this.#offset >= chunk_start && this.#offset < chunk_end) {
+            start_chunk = chunk;
+            break;
+          }
+          chunk_start = chunk_end;
+        }
+        if (this.#offset + this.size <= chunk_start + start_chunk.byteLength) {
+          controller.enqueue(
+            start_chunk.subarray(this.#offset - chunk_start, this.#offset + this.size - chunk_start)
+          );
+          controller.close();
+        } else {
+          controller.enqueue(start_chunk.subarray(this.#offset - chunk_start));
+          cursor = start_chunk.byteLength - this.#offset + chunk_start;
+        }
+      },
+      pull: async (controller) => {
+        chunk_index++;
+        let chunk = await this.#get_chunk(chunk_index);
+        if (!chunk) {
+          controller.error("incomplete file data");
+          controller.close();
+          return;
+        }
+        if (chunk.byteLength > this.size - cursor) {
+          chunk = chunk.subarray(0, this.size - cursor);
+        }
+        controller.enqueue(chunk);
+        cursor += chunk.byteLength;
+        if (cursor >= this.size) {
+          controller.close();
+        }
+      }
+    });
+  }
+  async text() {
+    return text_decoder.decode(await this.arrayBuffer());
+  }
 }
-
-/** @param {string} key */
-function safe_key(key) {
-	return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key)
-		? key
-		: escape_unsafe_chars(JSON.stringify(key));
+const path_regex = /^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/;
+function split_path(path) {
+  if (!path_regex.test(path)) {
+    throw new Error(`Invalid path ${path}`);
+  }
+  return path.split(/\.|\[|\]/).filter(Boolean);
 }
-
-/** @param {string} key */
-function safe_prop(key) {
-	return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key)
-		? `.${key}`
-		: `[${escape_unsafe_chars(JSON.stringify(key))}]`;
+function check_prototype_pollution(key) {
+  if (key === "__proto__" || key === "constructor" || key === "prototype") {
+    throw new Error(
+      `Invalid key "${key}"`
+    );
+  }
 }
-
-/** @param {any} thing */
-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 deep_set(object, keys, value) {
+  let current = object;
+  for (let i = 0; i < keys.length - 1; i += 1) {
+    const key = keys[i];
+    check_prototype_pollution(key);
+    const is_array = /^\d+$/.test(keys[i + 1]);
+    const exists = Object.hasOwn(current, key);
+    const inner = current[key];
+    if (exists && is_array !== Array.isArray(inner)) {
+      throw new Error(`Invalid array key ${keys[i + 1]}`);
+    }
+    if (!exists) {
+      current[key] = is_array ? [] : {};
+    }
+    current = current[key];
+  }
+  const final_key = keys[keys.length - 1];
+  check_prototype_pollution(final_key);
+  current[final_key] = value;
 }
 
 let public_env = {};
@@ -460,10 +374,7 @@ function set_hydrate_node(node) {
   return hydrate_node = node;
 }
 function hydrate_next() {
-  return set_hydrate_node(
-    /** @type {TemplateNode} */
-    get_next_sibling(hydrate_node)
-  );
+  return set_hydrate_node(get_next_sibling(hydrate_node));
 }
 function next(count = 1) {
   if (hydrating) {
@@ -533,7 +444,7 @@ function boundary(node, props, children) {
 class Boundary {
   /** @type {Boundary | null} */
   parent;
-  #pending = false;
+  is_pending = false;
   /** @type {TemplateNode} */
   #anchor;
   /** @type {TemplateNode | null} */
@@ -552,9 +463,16 @@ class Boundary {
   #failed_effect = null;
   /** @type {DocumentFragment | null} */
   #offscreen_fragment = null;
+  /** @type {TemplateNode | null} */
+  #pending_anchor = null;
   #local_pending_count = 0;
   #pending_count = 0;
+  #pending_count_update_queued = false;
   #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,
@@ -563,11 +481,6 @@ class Boundary {
    * @type {Source<number> | null}
    */
   #effect_pending = null;
-  #effect_pending_update = () => {
-    if (this.#effect_pending) {
-      internal_set(this.#effect_pending, this.#local_pending_count);
-    }
-  };
   #effect_pending_subscriber = createSubscriber(() => {
     this.#effect_pending = source(this.#local_pending_count);
     return () => {
@@ -585,7 +498,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) {
@@ -600,19 +513,26 @@ 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();
         try {
-          this.#main_effect = branch(() => children(this.#anchor));
+          this.#main_effect = branch(() => children(anchor));
         } catch (error) {
           this.error(error);
         }
         if (this.#pending_count > 0) {
           this.#show_pending_snippet();
         } else {
-          this.#pending = false;
+          this.is_pending = false;
         }
       }
+      return () => {
+        this.#pending_anchor?.remove();
+      };
     }, flags);
     if (hydrating) {
       this.#anchor = hydrate_node;
@@ -624,18 +544,16 @@ class Boundary {
     } catch (error) {
       this.error(error);
     }
-    this.#pending = false;
   }
   #hydrate_pending_content() {
     const pending = this.#props.pending;
-    if (!pending) {
-      return;
-    }
+    if (!pending) return;
     this.#pending_effect = branch(() => pending(this.#anchor));
-    Batch.enqueue(() => {
+    queue_micro_task(() => {
+      var anchor = this.#get_anchor();
       this.#main_effect = this.#run(() => {
         Batch.ensure();
-        return branch(() => this.#children(this.#anchor));
+        return branch(() => this.#children(anchor));
       });
       if (this.#pending_count > 0) {
         this.#show_pending_snippet();
@@ -647,16 +565,32 @@ class Boundary {
             this.#pending_effect = null;
           }
         );
-        this.#pending = false;
+        this.is_pending = false;
       }
     });
   }
+  #get_anchor() {
+    var anchor = this.#anchor;
+    if (this.is_pending) {
+      this.#pending_anchor = create_text();
+      this.#anchor.before(this.#pending_anchor);
+      anchor = this.#pending_anchor;
+    }
+    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;
@@ -689,6 +623,10 @@ class Boundary {
     );
     if (this.#main_effect !== null) {
       this.#offscreen_fragment = document.createDocumentFragment();
+      this.#offscreen_fragment.append(
+        /** @type {TemplateNode} */
+        this.#pending_anchor
+      );
       move_effect(this.#main_effect, this.#offscreen_fragment);
     }
     if (this.#pending_effect === null) {
@@ -709,7 +647,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;
@@ -719,9 +667,6 @@ class Boundary {
         this.#anchor.before(this.#offscreen_fragment);
         this.#offscreen_fragment = null;
       }
-      queue_micro_task(() => {
-        Batch.ensure().flush();
-      });
     }
   }
   /**
@@ -733,7 +678,14 @@ class Boundary {
   update_pending_count(d) {
     this.#update_pending_count(d);
     this.#local_pending_count += d;
-    effect_pending_updates.add(this.#effect_pending_update);
+    if (!this.#effect_pending || this.#pending_count_update_queued) return;
+    this.#pending_count_update_queued = true;
+    queue_micro_task(() => {
+      this.#pending_count_update_queued = false;
+      if (this.#effect_pending) {
+        internal_set(this.#effect_pending, this.#local_pending_count);
+      }
+    });
   }
   get_effect_pending() {
     this.#effect_pending_subscriber();
@@ -787,7 +739,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));
@@ -795,23 +747,20 @@ class Boundary {
       if (this.#pending_count > 0) {
         this.#show_pending_snippet();
       } else {
-        this.#pending = false;
+        this.is_pending = false;
       }
     };
-    var previous_reaction = active_reaction;
-    try {
-      set_active_reaction(null);
-      calling_on_error = true;
-      onerror?.(error, reset);
-      calling_on_error = false;
-    } catch (error2) {
-      invoke_error_boundary(error2, this.#effect && this.#effect.parent);
-    } finally {
-      set_active_reaction(previous_reaction);
-    }
-    if (failed) {
-      queue_micro_task(() => {
+    queue_micro_task(() => {
+      try {
+        calling_on_error = true;
+        onerror?.(error, reset);
+        calling_on_error = false;
+      } catch (error2) {
+        invoke_error_boundary(error2, this.#effect && this.#effect.parent);
+      }
+      if (failed) {
         this.#failed_effect = this.#run(() => {
+          Batch.ensure();
           this.#is_creating_fallback = true;
           try {
             return branch(() => {
@@ -832,20 +781,8 @@ class Boundary {
             this.#is_creating_fallback = false;
           }
         });
-      });
-    }
-  }
-}
-function move_effect(effect, fragment) {
-  var node = effect.nodes_start;
-  var end = effect.nodes_end;
-  while (node !== null) {
-    var next2 = node === end ? null : (
-      /** @type {TemplateNode} */
-      get_next_sibling(node)
-    );
-    fragment.append(node);
-    node = next2;
+      }
+    });
   }
 }
 const all_registered_events = /* @__PURE__ */ new Set();
@@ -906,12 +843,7 @@ function handle_event_propagation(event) {
         current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
         // -> the target could not have been disabled because it emits the event in the first place
         event.target === current_target)) {
-          if (is_array(delegated)) {
-            var [fn, ...data] = delegated;
-            fn.apply(current_target, [event, ...data]);
-          } else {
-            delegated.call(current_target, event);
-          }
+          delegated.call(current_target, event);
         }
       } catch (error) {
         if (throw_error) {
@@ -945,9 +877,8 @@ function assign_nodes(start, end) {
     /** @type {Effect} */
     active_effect
   );
-  if (effect.nodes_start === null) {
-    effect.nodes_start = start;
-    effect.nodes_end = end;
+  if (effect.nodes === null) {
+    effect.nodes = { start, end, a: null, t: null };
   }
 }
 function mount(component, options2) {
@@ -960,14 +891,10 @@ function hydrate(component, options2) {
   const was_hydrating = hydrating;
   const previous_hydrate_node = hydrate_node;
   try {
-    var anchor = (
-      /** @type {TemplateNode} */
-      get_first_child(target)
-    );
+    var anchor = get_first_child(target);
     while (anchor && (anchor.nodeType !== COMMENT_NODE || /** @type {Comment} */
     anchor.data !== HYDRATION_START)) {
-      anchor = /** @type {TemplateNode} */
-      get_next_sibling(anchor);
+      anchor = get_next_sibling(anchor);
     }
     if (!anchor) {
       throw HYDRATION_ERROR;
@@ -1055,7 +982,7 @@ function _mount(Component, { target, anchor, props = {}, events, context, intro
         }
         component = Component(anchor_node2, props) || {};
         if (hydrating) {
-          active_effect.nodes_end = hydrate_node;
+          active_effect.nodes.end = hydrate_node;
           if (hydrate_node === null || hydrate_node.nodeType !== COMMENT_NODE || /** @type {Comment} */
           hydrate_node.data !== HYDRATION_END) {
             hydration_mismatch();
@@ -1207,8 +1134,8 @@ function set_read_implementation(fn) {
 }
 function asClassComponent(component) {
   const component_constructor = asClassComponent$1(component);
-  const _render = (props, { context } = {}) => {
-    const result = render(component, { props, context });
+  const _render = (props, { context, csp } = {}) => {
+    const result = render(component, { props, context, csp });
     const munged = Object.defineProperties(
       /** @type {LegacyRenderResult & PromiseLike<LegacyRenderResult>} */
       {},
@@ -1276,7 +1203,7 @@ function Root($$renderer, $$props) {
       $$renderer2.push("<!--[-->");
       const Pyramid_0 = constructors[0];
       $$renderer2.push(`<!---->`);
-      Pyramid_0($$renderer2, {
+      Pyramid_0?.($$renderer2, {
         data: data_0,
         form,
         params: page.params,
@@ -1285,7 +1212,7 @@ function Root($$renderer, $$props) {
             $$renderer3.push("<!--[-->");
             const Pyramid_1 = constructors[1];
             $$renderer3.push(`<!---->`);
-            Pyramid_1($$renderer3, {
+            Pyramid_1?.($$renderer3, {
               data: data_1,
               form,
               params: page.params,
@@ -1294,7 +1221,7 @@ function Root($$renderer, $$props) {
                   $$renderer4.push("<!--[-->");
                   const Pyramid_2 = constructors[2];
                   $$renderer4.push(`<!---->`);
-                  Pyramid_2($$renderer4, {
+                  Pyramid_2?.($$renderer4, {
                     data: data_2,
                     form,
                     params: page.params,
@@ -1303,7 +1230,7 @@ function Root($$renderer, $$props) {
                         $$renderer5.push("<!--[-->");
                         const Pyramid_3 = constructors[3];
                         $$renderer5.push(`<!---->`);
-                        Pyramid_3($$renderer5, {
+                        Pyramid_3?.($$renderer5, {
                           data: data_3,
                           form,
                           params: page.params,
@@ -1312,7 +1239,7 @@ function Root($$renderer, $$props) {
                               $$renderer6.push("<!--[-->");
                               const Pyramid_4 = constructors[4];
                               $$renderer6.push(`<!---->`);
-                              Pyramid_4($$renderer6, {
+                              Pyramid_4?.($$renderer6, {
                                 data: data_4,
                                 form,
                                 params: page.params,
@@ -1321,13 +1248,13 @@ function Root($$renderer, $$props) {
                                     $$renderer7.push("<!--[-->");
                                     const Pyramid_5 = constructors[5];
                                     $$renderer7.push(`<!---->`);
-                                    Pyramid_5($$renderer7, {
+                                    Pyramid_5?.($$renderer7, {
                                       data: data_5,
                                       form,
                                       params: page.params,
                                       children: ($$renderer8) => {
                                         $$renderer8.push(`<!---->`);
-                                        Pyramid_6($$renderer8, { data: data_6, form, params: page.params });
+                                        Pyramid_6?.($$renderer8, { data: data_6, form, params: page.params });
                                         $$renderer8.push(`<!---->`);
                                       },
                                       $$slots: { default: true }
@@ -1337,7 +1264,7 @@ function Root($$renderer, $$props) {
                                     $$renderer7.push("<!--[!-->");
                                     const Pyramid_5 = constructors[5];
                                     $$renderer7.push(`<!---->`);
-                                    Pyramid_5($$renderer7, { data: data_5, form, params: page.params });
+                                    Pyramid_5?.($$renderer7, { data: data_5, form, params: page.params });
                                     $$renderer7.push(`<!---->`);
                                   }
                                   $$renderer7.push(`<!--]-->`);
@@ -1349,7 +1276,7 @@ function Root($$renderer, $$props) {
                               $$renderer6.push("<!--[!-->");
                               const Pyramid_4 = constructors[4];
                               $$renderer6.push(`<!---->`);
-                              Pyramid_4($$renderer6, { data: data_4, form, params: page.params });
+                              Pyramid_4?.($$renderer6, { data: data_4, form, params: page.params });
                               $$renderer6.push(`<!---->`);
                             }
                             $$renderer6.push(`<!--]-->`);
@@ -1361,7 +1288,7 @@ function Root($$renderer, $$props) {
                         $$renderer5.push("<!--[!-->");
                         const Pyramid_3 = constructors[3];
                         $$renderer5.push(`<!---->`);
-                        Pyramid_3($$renderer5, { data: data_3, form, params: page.params });
+                        Pyramid_3?.($$renderer5, { data: data_3, form, params: page.params });
                         $$renderer5.push(`<!---->`);
                       }
                       $$renderer5.push(`<!--]-->`);
@@ -1373,7 +1300,7 @@ function Root($$renderer, $$props) {
                   $$renderer4.push("<!--[!-->");
                   const Pyramid_2 = constructors[2];
                   $$renderer4.push(`<!---->`);
-                  Pyramid_2($$renderer4, { data: data_2, form, params: page.params });
+                  Pyramid_2?.($$renderer4, { data: data_2, form, params: page.params });
                   $$renderer4.push(`<!---->`);
                 }
                 $$renderer4.push(`<!--]-->`);
@@ -1385,7 +1312,7 @@ function Root($$renderer, $$props) {
             $$renderer3.push("<!--[!-->");
             const Pyramid_1 = constructors[1];
             $$renderer3.push(`<!---->`);
-            Pyramid_1($$renderer3, { data: data_1, form, params: page.params });
+            Pyramid_1?.($$renderer3, { data: data_1, form, params: page.params });
             $$renderer3.push(`<!---->`);
           }
           $$renderer3.push(`<!--]-->`);
@@ -1397,7 +1324,7 @@ function Root($$renderer, $$props) {
       $$renderer2.push("<!--[!-->");
       const Pyramid_0 = constructors[0];
       $$renderer2.push(`<!---->`);
-      Pyramid_0($$renderer2, { data: data_0, form, params: page.params });
+      Pyramid_0?.($$renderer2, { data: data_0, form, params: page.params });
       $$renderer2.push(`<!---->`);
     }
     $$renderer2.push(`<!--]--> `);
@@ -1497,7 +1424,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: "1hf9b6a"
+  version_hash: "bx0koo"
 };
 async function get_hooks() {
   let handle;
@@ -1818,6 +1745,14 @@ function requireSetCookie () {
 	  silent: false,
 	};
 
+	function isForbiddenKey(key) {
+	  return typeof key !== "string" || key in {};
+	}
+
+	function createNullObj() {
+	  return Object.create(null);
+	}
+
 	function isNonEmptyString(str) {
 	  return typeof str === "string" && !!str.trim();
 	}
@@ -1834,30 +1769,35 @@ function requireSetCookie () {
 	    ? Object.assign({}, defaultParseOptions, options)
 	    : defaultParseOptions;
 
+	  if (isForbiddenKey(name)) {
+	    return null;
+	  }
+
 	  try {
 	    value = options.decodeValues ? decodeURIComponent(value) : value; // decode cookie value
 	  } catch (e) {
 	    console.error(
-	      "set-cookie-parser encountered an error while decoding a cookie with value '" +
-	        value +
-	        "'. Set options.decodeValues to false to disable this feature.",
+	      "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
 	      e
 	    );
 	  }
 
-	  var cookie = {
-	    name: name,
-	    value: value,
-	  };
+	  var cookie = createNullObj();
+	  cookie.name = name;
+	  cookie.value = value;
 
 	  parts.forEach(function (part) {
 	    var sides = part.split("=");
 	    var key = sides.shift().trimLeft().toLowerCase();
+	    if (isForbiddenKey(key)) {
+	      return;
+	    }
 	    var value = sides.join("=");
 	    if (key === "expires") {
 	      cookie.expires = new Date(value);
 	    } else if (key === "max-age") {
-	      cookie.maxAge = parseInt(value, 10);
+	      var n = parseInt(value, 10);
+	      if (!Number.isNaN(n)) cookie.maxAge = n;
 	    } else if (key === "secure") {
 	      cookie.secure = true;
 	    } else if (key === "httponly") {
@@ -1866,7 +1806,7 @@ function requireSetCookie () {
 	      cookie.sameSite = value;
 	    } else if (key === "partitioned") {
 	      cookie.partitioned = true;
-	    } else {
+	    } else if (key) {
 	      cookie[key] = value;
 	    }
 	  });
@@ -1899,7 +1839,7 @@ function requireSetCookie () {
 	    if (!options.map) {
 	      return [];
 	    } else {
-	      return {};
+	      return createNullObj();
 	    }
 	  }
 
@@ -1909,7 +1849,7 @@ function requireSetCookie () {
 	      // but getSetCookie returns an uncombined array
 	      input = input.headers.getSetCookie();
 	    } else if (input.headers["set-cookie"]) {
-	      // fast-path for node.js (which automatically normalizes header names to lower-case
+	      // fast-path for node.js (which automatically normalizes header names to lower-case)
 	      input = input.headers["set-cookie"];
 	    } else {
 	      // slow-path for other environments - see #25
@@ -1933,14 +1873,19 @@ function requireSetCookie () {
 	  }
 
 	  if (!options.map) {
-	    return input.filter(isNonEmptyString).map(function (str) {
-	      return parseString(str, options);
-	    });
+	    return input
+	      .filter(isNonEmptyString)
+	      .map(function (str) {
+	        return parseString(str, options);
+	      })
+	      .filter(Boolean);
 	  } else {
-	    var cookies = {};
+	    var cookies = createNullObj();
 	    return input.filter(isNonEmptyString).reduce(function (cookies, str) {
 	      var cookie = parseString(str, options);
-	      cookies[cookie.name] = cookie;
+	      if (cookie && !isForbiddenKey(cookie.name)) {
+	        cookies[cookie.name] = cookie;
+	      }
 	      return cookies;
 	    }, cookies);
 	  }
@@ -2097,7 +2042,8 @@ function is_form_content_type(request) {
     request,
     "application/x-www-form-urlencoded",
     "multipart/form-data",
-    "text/plain"
+    "text/plain",
+    BINARY_FORM_CONTENT_TYPE
   );
 }
 function coalesce_to_error(err) {
@@ -2649,46 +2595,29 @@ function try_serialize(data, fn, route_id) {
     throw error2;
   }
 }
-function defer() {
-  let fulfil;
-  let reject;
-  const promise = new Promise((f, r) => {
-    fulfil = f;
-    reject = r;
-  });
-  return { promise, fulfil, reject };
-}
 function create_async_iterator() {
-  let count = 0;
-  const deferred = [defer()];
+  let resolved = -1;
+  let returned = -1;
+  const deferred = [];
   return {
     iterate: (transform = (x) => x) => {
       return {
         [Symbol.asyncIterator]() {
           return {
             next: async () => {
-              const next = await deferred[0].promise;
-              if (!next.done) {
-                deferred.shift();
-                return { value: transform(next.value), done: false };
-              }
-              return next;
+              const next = deferred[++returned];
+              if (!next) return { value: null, done: true };
+              const value = await next.promise;
+              return { value: transform(value), done: false };
             }
           };
         }
       };
     },
     add: (promise) => {
-      count += 1;
+      deferred.push(with_resolvers());
       void promise.then((value) => {
-        deferred[deferred.length - 1].fulfil({
-          value,
-          done: false
-        });
-        deferred.push(defer());
-        if (--count === 0) {
-          deferred[deferred.length - 1].fulfil({ done: true });
-        }
+        deferred[++resolved].resolve(value);
       });
     }
   };
@@ -3056,7 +2985,7 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
     }
     let teed_body;
     const proxy = new Proxy(response, {
-      get(response2, key2, _receiver) {
+      get(response2, key2, receiver) {
         async function push_fetched(body2, is_b64) {
           const status_number = Number(response2.status);
           if (isNaN(status_number)) {
@@ -3136,7 +3065,22 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
             return body2 ? JSON.parse(body2) : void 0;
           };
         }
-        return Reflect.get(response2, key2, response2);
+        const value = Reflect.get(response2, key2, response2);
+        if (value instanceof Function) {
+          return Object.defineProperties(
+            /**
+             * @this {any}
+             */
+            function() {
+              return Reflect.apply(value, this === receiver ? response2 : this, arguments);
+            },
+            {
+              name: { value: value.name },
+              length: { value: value.length }
+            }
+          );
+        }
+        return value;
       }
     });
     if (csr) {
@@ -3986,7 +3930,7 @@ ${indent}}`);
       for (const [info, cache] of remote_cache) {
         if (!info.id) continue;
         for (const key2 in cache) {
-          remote[create_remote_cache_key(info.id, key2)] = await cache[key2];
+          remote[create_remote_key(info.id, key2)] = await cache[key2];
         }
       }
       const replacer = (thing) => {
@@ -4097,7 +4041,7 @@ ${indent}}`);
       async start(controller) {
         controller.enqueue(text_encoder.encode(transformed + "\n"));
         for await (const chunk of chunks) {
-          controller.enqueue(text_encoder.encode(chunk));
+          if (chunk.length) controller.enqueue(text_encoder.encode(chunk));
         }
         controller.close();
       },
@@ -4366,24 +4310,18 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
           )}`
         );
       }
-      const form_data = await event.request.formData();
-      form_client_refreshes = /** @type {string[]} */
-      JSON.parse(
-        /** @type {string} */
-        form_data.get("sveltekit:remote_refreshes") ?? "[]"
-      );
-      form_data.delete("sveltekit:remote_refreshes");
-      if (additional_args) {
-        form_data.set("sveltekit:id", decodeURIComponent(additional_args));
+      const { data: data2, meta, form_data } = await deserialize_binary_form(event.request);
+      if (additional_args && !("id" in data2)) {
+        data2.id = JSON.parse(decodeURIComponent(additional_args));
       }
       const fn2 = info.fn;
-      const data2 = await with_request_store({ event, state }, () => fn2(form_data));
+      const result = await with_request_store({ event, state }, () => fn2(data2, meta, form_data));
       return json(
         /** @type {RemoteFunctionResponse} */
         {
           type: "result",
-          result: stringify(data2, transport),
-          refreshes: data2.issues ? {} : await serialize_refreshes(form_client_refreshes)
+          result: stringify(result, transport),
+          refreshes: result.issues ? void 0 : await serialize_refreshes(meta.remote_refreshes)
         }
       );
     }
@@ -4423,7 +4361,7 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
         {
           type: "redirect",
           location: error2.location,
-          refreshes: await serialize_refreshes(form_client_refreshes ?? [])
+          refreshes: await serialize_refreshes(form_client_refreshes)
         }
       );
     }
@@ -4447,16 +4385,18 @@ async function handle_remote_call_internal(event, state, options2, manifest, id)
   }
   async function serialize_refreshes(client_refreshes) {
     const refreshes = state.refreshes ?? {};
-    for (const key2 of client_refreshes) {
-      if (refreshes[key2] !== void 0) continue;
-      const [hash3, name2, payload] = key2.split("/");
-      const loader = manifest._.remotes[hash3];
-      const fn2 = (await loader?.())?.default?.[name2];
-      if (!fn2) error(400, "Bad Request");
-      refreshes[key2] = with_request_store(
-        { event, state },
-        () => fn2(parse_remote_arg(payload, transport))
-      );
+    if (client_refreshes) {
+      for (const key2 of client_refreshes) {
+        if (refreshes[key2] !== void 0) continue;
+        const [hash3, name2, payload] = key2.split("/");
+        const loader = manifest._.remotes[hash3];
+        const fn2 = (await loader?.())?.default?.[name2];
+        if (!fn2) error(400, "Bad Request");
+        refreshes[key2] = with_request_store(
+          { event, state },
+          () => fn2(parse_remote_arg(payload, transport))
+        );
+      }
     }
     if (Object.keys(refreshes).length === 0) {
       return void 0;
@@ -4511,16 +4451,16 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
     form = with_request_store({ event, state }, () => form.for(JSON.parse(action_id)));
   }
   try {
-    const form_data = await event.request.formData();
     const fn = (
       /** @type {RemoteInfo & { type: 'form' }} */
       /** @type {any} */
       form.__.fn
     );
-    if (action_id && !form_data.has("id")) {
-      form_data.set("sveltekit:id", decodeURIComponent(action_id));
+    const { data, meta, form_data } = await deserialize_binary_form(event.request);
+    if (action_id && !("id" in data)) {
+      data.id = JSON.parse(decodeURIComponent(action_id));
     }
-    await with_request_store({ event, state }, () => fn(form_data));
+    await with_request_store({ event, state }, () => fn(data, meta, form_data));
     return {
       type: "success",
       status: 200
@@ -5337,7 +5277,11 @@ async function internal_respond(request, options2, manifest, state) {
             "Use `event.cookies.set(name, value, options)` instead of `event.setHeaders` to set cookies"
           );
         } else if (lower in headers2) {
-          throw new Error(`"${key2}" header is already set`);
+          if (lower === "server-timing") {
+            headers2[lower] += ", " + value;
+          } else {
+            throw new Error(`"${key2}" header is already set`);
+          }
         } else {
           headers2[lower] = value;
           if (state.prerendering && lower === "cache-control") {
@@ -5385,20 +5329,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) {