@axium/server 0.22.11 → 0.22.13

package/build/server/index.js

@@ -1,7 +1,8 @@
-import { r as render, L as LEGACY_PROPS, U as UNOWNED, E as ERROR_VALUE, C as COMMENT_NODE, H as HYDRATION_START, a as HYDRATION_ERROR, b as HYDRATION_END, S as STATE_SYMBOL, c as UNINITIALIZED, D as DERIVED, d as DIRTY, e as CLEAN, M as MAYBE_DIRTY, f as DISCONNECTED, I as INERT, g as EFFECT, A as ASYNC, B as BLOCK_EFFECT, h as DEV, i as is_passive_event, j as BRANCH_EFFECT, R as ROOT_EFFECT, k as DESTROYED, l as USER_EFFECT, m as STALE_REACTION, n as REACTION_IS_UPDATING, o as EFFECT_RAN, p as EFFECT_PRESERVED, q as HEAD_EFFECT, s as BOUNDARY_EFFECT, t as EFFECT_TRANSPARENT, u as INSPECT_EFFECT, v as push$1, w as setContext, x as pop$1 } from './chunks/index-apo9QTc6.js';
+import { r as render, L as LEGACY_PROPS, U as UNOWNED, E as ERROR_VALUE, C as COMMENT_NODE, H as HYDRATION_START, a as HYDRATION_ERROR, b as HYDRATION_END, S as STATE_SYMBOL, c as UNINITIALIZED, D as DERIVED, d as DIRTY, e as CLEAN, M as MAYBE_DIRTY, f as DISCONNECTED, g as DEV, I as INERT, h as EFFECT, A as ASYNC, B as BLOCK_EFFECT, i as is_passive_event, j as BRANCH_EFFECT, R as ROOT_EFFECT, k as DESTROYED, l as REACTION_IS_UPDATING, m as EFFECT_RAN, n as EFFECT_PRESERVED, o as HEAD_EFFECT, p as BOUNDARY_EFFECT, q as EFFECT_TRANSPARENT, s as INSPECT_EFFECT, t as STALE_REACTION, u as push$1, v as setContext, w as pop$1, x as USER_EFFECT } from './chunks/index-RTKpMYZ1.js';
 import { json, text, error } from '@sveltejs/kit';
 import { Redirect, SvelteKitError, HttpError, ActionFailure } from '@sveltejs/kit/internal';
-import { d as define_property, s as safe_equals, o as object_prototype, a as array_prototype, g as get_descriptor, i as is_extensible, b as array_from, c as deferred, e as equals, f as get_prototype_of, h as is_array, r as run_all, j as index_of, 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, t as validate_page_exports, u as resolve, w as make_trackable, x as readable, y as writable } from './chunks/exports-Cy4FWdYs.js';
+import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
+import { d as define_property, s as safe_equals, o as object_prototype, a as array_prototype, g as get_descriptor, i as is_extensible, b as array_from, e as equals, c as get_prototype_of, f as is_array, h as deferred, r as run_all, j as index_of, t as text_decoder, k as base64_decode, l as decode_pathname, m as decode_params, n as normalize_path, p as disable_search, v as validate_layout_server_exports, q as validate_layout_exports, u as validate_page_server_exports, w as validate_page_exports, x as text_encoder, y as resolve, z as make_trackable, A as get_relative_path, B as base64_encode, C as readable, D as writable } from './chunks/utils-h74ns7K6.js';
 import { parse as parse$1, serialize } from 'cookie';
 
 let base = "";
@@ -131,7 +132,7 @@ function stringify_key(key) {
 	return is_identifier.test(key) ? '.' + key : '[' + JSON.stringify(key) + ']';
 }
 
-const chars$1 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+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)$/;
@@ -430,8 +431,8 @@ function get_name(num) {
 	let name = '';
 
 	do {
-		name = chars$1[num % chars$1.length] + name;
-		num = ~~(num / chars$1.length) - 1;
+		name = chars[num % chars.length] + name;
+		num = ~~(num / chars.length) - 1;
 	} while (num >= 0);
 
 	return reserved.test(name) ? `${name}0` : name;
@@ -955,45 +956,6 @@ function stringify_primitive(thing) {
 	return String(thing);
 }
 
-let request_event = null;
-let als;
-import('node:async_hooks').then((hooks) => als = new hooks.AsyncLocalStorage()).catch(() => {
-});
-function with_event(event, fn) {
-  try {
-    request_event = event;
-    return als ? als.run(event, fn) : fn();
-  } finally {
-    request_event = null;
-  }
-}
-const INVALIDATED_PARAM = "x-sveltekit-invalidated";
-const TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
-function stringify(data, transport) {
-  const encoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode]));
-  return stringify$1(data, encoders);
-}
-function parse_remote_arg(string, transport) {
-  if (!string) return void 0;
-  const decoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.decode]));
-  const base64_restored = string.replace(/-/g, "+").replace(/_/g, "/");
-  const binary_string = atob(base64_restored);
-  const utf8_bytes = new Uint8Array([...binary_string].map((char) => char.charCodeAt(0)));
-  const json_string = new TextDecoder().decode(utf8_bytes);
-  return parse(json_string, decoders);
-}
-const EVENT_STATE = Symbol("remote");
-function create_event_state(state, options) {
-  return {
-    prerendering: state.prerendering,
-    transport: options.hooks.transport,
-    handleValidationError: options.hooks.handleValidationError
-  };
-}
-function get_event_state(event) {
-  return event[EVENT_STATE];
-}
-
 let public_env = {};
 let safe_public_env = {};
 function set_public_env(environment) {
@@ -1226,13 +1188,14 @@ function dequeue() {
 let queued_root_effects = [];
 let last_scheduled_effect = null;
 let is_flushing = false;
+let is_flushing_sync = false;
 class Batch {
   /**
    * The current values of any sources that are updated in this batch
    * They keys of this map are identical to `this.#previous`
    * @type {Map<Source, any>}
    */
-  #current = /* @__PURE__ */ new Map();
+  current = /* @__PURE__ */ new Map();
   /**
    * The values of any sources that are updated in this batch _before_ those updates took place.
    * They keys of this map are identical to `this.#current`
@@ -1290,6 +1253,16 @@ class Batch {
    * @type {Effect[]}
    */
   #block_effects = [];
+  /**
+   * Deferred effects (which run after async work has completed) that are DIRTY
+   * @type {Effect[]}
+   */
+  #dirty_effects = [];
+  /**
+   * Deferred effects that are MAYBE_DIRTY
+   * @type {Effect[]}
+   */
+  #maybe_dirty_effects = [];
   /**
    * A set of branches that still exist, but will be destroyed when this batch
    * is committed — we skip over these during `process`
@@ -1300,13 +1273,13 @@ class Batch {
    *
    * @param {Effect[]} root_effects
    */
-  #process(root_effects) {
+  process(root_effects) {
     queued_root_effects = [];
     var current_values = null;
     if (batches.size > 1) {
       current_values = /* @__PURE__ */ new Map();
       batch_deriveds = /* @__PURE__ */ new Map();
-      for (const [source2, current] of this.#current) {
+      for (const [source2, current] of this.current) {
         current_values.set(source2, { v: source2.v, wv: source2.wv });
         source2.v = current;
       }
@@ -1324,19 +1297,25 @@ class Batch {
       this.#traverse_effect_tree(root2);
     }
     if (this.#async_effects.length === 0 && this.#pending === 0) {
+      this.#commit();
       var render_effects = this.#render_effects;
       var effects = this.#effects;
       this.#render_effects = [];
       this.#effects = [];
       this.#block_effects = [];
-      this.#commit();
+      current_batch = null;
       flush_queued_effects(render_effects);
       flush_queued_effects(effects);
+      if (current_batch === null) {
+        current_batch = this;
+      } else {
+        batches.delete(this);
+      }
       this.#deferred?.resolve();
     } else {
-      for (const e of this.#render_effects) set_signal_status(e, CLEAN);
-      for (const e of this.#effects) set_signal_status(e, CLEAN);
-      for (const e of this.#block_effects) set_signal_status(e, CLEAN);
+      this.#defer_effects(this.#render_effects);
+      this.#defer_effects(this.#effects);
+      this.#defer_effects(this.#block_effects);
     }
     if (current_values) {
       for (const [source2, { v, wv }] of current_values) {
@@ -1373,11 +1352,11 @@ class Batch {
           effect.f ^= CLEAN;
         } else if ((flags & EFFECT) !== 0) {
           this.#effects.push(effect);
-        } else if (is_dirty(effect)) {
+        } else if ((flags & CLEAN) === 0) {
           if ((flags & ASYNC) !== 0) {
             var effects = effect.b?.pending ? this.#boundary_async_effects : this.#async_effects;
             effects.push(effect);
-          } else {
+          } else if (is_dirty(effect)) {
             if ((effect.f & BLOCK_EFFECT) !== 0) this.#block_effects.push(effect);
             update_effect(effect);
           }
@@ -1396,6 +1375,17 @@ class Batch {
       }
     }
   }
+  /**
+   * @param {Effect[]} effects
+   */
+  #defer_effects(effects) {
+    for (const e of effects) {
+      const target = (e.f & DIRTY) !== 0 ? this.#dirty_effects : this.#maybe_dirty_effects;
+      target.push(e);
+      set_signal_status(e, CLEAN);
+    }
+    effects.length = 0;
+  }
   /**
    * Associate a change to a given source with the current
    * batch, noting its previous and current values
@@ -1406,7 +1396,7 @@ class Batch {
     if (!this.#previous.has(source2)) {
       this.#previous.set(source2, value);
     }
-    this.#current.set(source2, source2.v);
+    this.current.set(source2, source2.v);
   }
   activate() {
     current_batch = this;
@@ -1426,7 +1416,7 @@ class Batch {
   }
   flush() {
     if (queued_root_effects.length > 0) {
-      this.flush_effects();
+      flush_effects();
     } else {
       this.#commit();
     }
@@ -1438,27 +1428,6 @@ class Batch {
     }
     this.deactivate();
   }
-  flush_effects() {
-    var was_updating_effect = is_updating_effect;
-    is_flushing = true;
-    try {
-      var flush_count = 0;
-      set_is_updating_effect(true);
-      while (queued_root_effects.length > 0) {
-        if (flush_count++ > 1e3) {
-          var updates, entry;
-          if (DEV) ;
-          infinite_loop_guard();
-        }
-        this.#process(queued_root_effects);
-        old_values.clear();
-      }
-    } finally {
-      is_flushing = false;
-      set_is_updating_effect(was_updating_effect);
-      last_scheduled_effect = null;
-    }
-  }
   /**
    * Append and remove branches to/from the DOM
    */
@@ -1476,16 +1445,12 @@ class Batch {
   decrement() {
     this.#pending -= 1;
     if (this.#pending === 0) {
-      for (const e of this.#render_effects) {
+      for (const e of this.#dirty_effects) {
         set_signal_status(e, DIRTY);
         schedule_effect(e);
       }
-      for (const e of this.#effects) {
-        set_signal_status(e, DIRTY);
-        schedule_effect(e);
-      }
-      for (const e of this.#block_effects) {
-        set_signal_status(e, DIRTY);
+      for (const e of this.#maybe_dirty_effects) {
+        set_signal_status(e, MAYBE_DIRTY);
         schedule_effect(e);
       }
       this.#render_effects = [];
@@ -1502,11 +1467,11 @@ class Batch {
   settled() {
     return (this.#deferred ??= deferred()).promise;
   }
-  static ensure(autoflush = true) {
+  static ensure() {
     if (current_batch === null) {
       const batch = current_batch = new Batch();
       batches.add(current_batch);
-      if (autoflush) {
+      if (!is_flushing_sync) {
         Batch.enqueue(() => {
           if (current_batch !== batch) {
             return;
@@ -1526,21 +1491,49 @@ class Batch {
   }
 }
 function flushSync(fn) {
-  var result;
-  const batch = Batch.ensure(false);
-  while (true) {
-    flush_tasks();
-    if (queued_root_effects.length === 0) {
-      if (batch === current_batch) {
-        batch.flush();
+  var was_flushing_sync = is_flushing_sync;
+  is_flushing_sync = true;
+  try {
+    var result;
+    if (fn) ;
+    while (true) {
+      flush_tasks();
+      if (queued_root_effects.length === 0) {
+        current_batch?.flush();
+        if (queued_root_effects.length === 0) {
+          last_scheduled_effect = null;
+          return (
+            /** @type {T} */
+            result
+          );
+        }
       }
-      last_scheduled_effect = null;
-      return (
-        /** @type {T} */
-        result
-      );
+      flush_effects();
+    }
+  } finally {
+    is_flushing_sync = was_flushing_sync;
+  }
+}
+function flush_effects() {
+  var was_updating_effect = is_updating_effect;
+  is_flushing = true;
+  try {
+    var flush_count = 0;
+    set_is_updating_effect(true);
+    while (queued_root_effects.length > 0) {
+      var batch = Batch.ensure();
+      if (flush_count++ > 1e3) {
+        var updates, entry;
+        if (DEV) ;
+        infinite_loop_guard();
+      }
+      batch.process(queued_root_effects);
+      old_values.clear();
     }
-    batch.flush_effects();
+  } finally {
+    is_flushing = false;
+    set_is_updating_effect(was_updating_effect);
+    last_scheduled_effect = null;
   }
 }
 function infinite_loop_guard() {
@@ -1550,31 +1543,33 @@ function infinite_loop_guard() {
     invoke_error_boundary(error, last_scheduled_effect);
   }
 }
+let eager_block_effects = null;
 function flush_queued_effects(effects) {
   var length = effects.length;
   if (length === 0) return;
-  for (var i = 0; i < length; i++) {
-    var effect = effects[i];
-    if ((effect.f & (DESTROYED | INERT)) === 0) {
-      if (is_dirty(effect)) {
-        var wv = write_version;
-        update_effect(effect);
-        if (effect.deps === null && effect.first === null && effect.nodes_start === null) {
-          if (effect.teardown === null && effect.ac === null) {
-            unlink_effect(effect);
-          } else {
-            effect.fn = null;
-          }
+  var i = 0;
+  while (i < length) {
+    var effect = effects[i++];
+    if ((effect.f & (DESTROYED | INERT)) === 0 && is_dirty(effect)) {
+      eager_block_effects = [];
+      update_effect(effect);
+      if (effect.deps === null && effect.first === null && effect.nodes_start === null) {
+        if (effect.teardown === null && effect.ac === null) {
+          unlink_effect(effect);
+        } else {
+          effect.fn = null;
         }
-        if (write_version > wv && (effect.f & USER_EFFECT) !== 0) {
-          break;
+      }
+      if (eager_block_effects.length > 0) {
+        old_values.clear();
+        for (const e of eager_block_effects) {
+          update_effect(e);
         }
+        eager_block_effects = [];
       }
     }
   }
-  for (; i < length; i += 1) {
-    schedule_effect(effects[i]);
-  }
+  eager_block_effects = null;
 }
 function schedule_effect(signal) {
   var effect = last_scheduled_effect = signal;
@@ -1636,7 +1631,7 @@ function internal_set(source2, value) {
       old_values.set(source2, old_value);
     }
     source2.v = value;
-    const batch = Batch.ensure();
+    var batch = Batch.ensure();
     batch.capture(source2, old_value);
     if ((source2.f & DERIVED) !== 0) {
       if ((source2.f & DIRTY) !== 0) {
@@ -1669,7 +1664,8 @@ function mark_reactions(signal, status) {
   for (var i = 0; i < length; i++) {
     var reaction = reactions[i];
     var flags = reaction.f;
-    if ((flags & DIRTY) === 0) {
+    var not_dirty = (flags & DIRTY) === 0;
+    if (not_dirty) {
       set_signal_status(reaction, status);
     }
     if ((flags & DERIVED) !== 0) {
@@ -1678,7 +1674,15 @@ function mark_reactions(signal, status) {
         reaction,
         MAYBE_DIRTY
       );
-    } else if ((flags & DIRTY) === 0) {
+    } else if (not_dirty) {
+      if ((flags & BLOCK_EFFECT) !== 0) {
+        if (eager_block_effects !== null) {
+          eager_block_effects.push(
+            /** @type {Effect} */
+            reaction
+          );
+        }
+      }
       schedule_effect(
         /** @type {Effect} */
         reaction
@@ -1914,6 +1918,18 @@ function get_next_sibling(node) {
 function clear_text_content(node) {
   node.textContent = "";
 }
+function without_reactive_context(fn) {
+  var previous_reaction = active_reaction;
+  var previous_effect = active_effect;
+  set_active_reaction(null);
+  set_active_effect(null);
+  try {
+    return fn();
+  } finally {
+    set_active_reaction(previous_reaction);
+    set_active_effect(previous_effect);
+  }
+}
 function push_effect(effect, parent_effect) {
   var parent_last = parent_effect.last;
   if (parent_last === null) {
@@ -1963,7 +1979,7 @@ function create_effect(type, fn, sync, push2 = true) {
     if (parent !== null) {
       push_effect(effect, parent);
     }
-    if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
+    if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0 && (type & ROOT_EFFECT) === 0) {
       var derived = (
         /** @type {Derived} */
         active_reaction
@@ -2015,7 +2031,12 @@ function destroy_effect_children(signal, remove_dom = false) {
   var effect = signal.first;
   signal.first = signal.last = null;
   while (effect !== null) {
-    effect.ac?.abort(STALE_REACTION);
+    const controller = effect.ac;
+    if (controller !== null) {
+      without_reactive_context(() => {
+        controller.abort(STALE_REACTION);
+      });
+    }
     var next = effect.next;
     if ((effect.f & ROOT_EFFECT) !== 0) {
       effect.parent = null;
@@ -2267,15 +2288,18 @@ function update_reaction(reaction) {
   untracking = false;
   update_version = ++read_version;
   if (reaction.ac !== null) {
-    reaction.ac.abort(STALE_REACTION);
+    without_reactive_context(() => {
+      reaction.ac.abort(STALE_REACTION);
+    });
     reaction.ac = null;
   }
   try {
     reaction.f |= REACTION_IS_UPDATING;
-    var result = (
+    var fn = (
       /** @type {Function} */
-      (0, reaction.fn)()
+      reaction.fn
     );
+    var result = fn();
     var deps = reaction.deps;
     if (new_deps !== null) {
       var i;
@@ -2497,6 +2521,7 @@ function set_signal_status(signal, status) {
 }
 const all_registered_events = /* @__PURE__ */ new Set();
 const root_event_handles = /* @__PURE__ */ new Set();
+let last_propagated_event = null;
 function handle_event_propagation(event) {
   var handler_element = this;
   var owner_document = (
@@ -2509,8 +2534,9 @@ function handle_event_propagation(event) {
     /** @type {null | Element} */
     path[0] || event.target
   );
+  last_propagated_event = event;
   var path_idx = 0;
-  var handled_at = event.__root;
+  var handled_at = last_propagated_event === event && event.__root;
   if (handled_at) {
     var at_idx = path.indexOf(handled_at);
     if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
@@ -2635,16 +2661,19 @@ function hydrate(component, options2) {
       instance
     );
   } catch (error) {
-    if (error === HYDRATION_ERROR) {
-      if (options2.recover === false) {
-        hydration_failed();
-      }
-      init_operations();
-      clear_text_content(target);
-      set_hydrating(false);
-      return mount(component, options2);
+    if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) {
+      throw error;
+    }
+    if (error !== HYDRATION_ERROR) {
+      console.warn("Failed to hydrate: ", error);
     }
-    throw error;
+    if (options2.recover === false) {
+      hydration_failed();
+    }
+    init_operations();
+    clear_text_content(target);
+    set_hydrating(false);
+    return mount(component, options2);
   } finally {
     set_hydrating(was_hydrating);
     set_hydrate_node(previous_hydrate_node);
@@ -2915,6 +2944,7 @@ const options = {
   preload_strategy: "modulepreload",
   root,
   service_worker: false,
+  service_worker_options: void 0,
   templates: {
     app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<link rel="icon" href="' + assets + '/favicon.svg" />\n		<meta name="viewport" content="width=device-width, initial-scale=1" />\n		<meta name="color-scheme" content="dark light" />\n		<link rel="stylesheet" href="' + assets + '/theme.css" />\n		<link rel="stylesheet" href="' + assets + '/styles.css" />\n		<link rel="preload" href="' + assets + '/icons/light.svg" as="image" type="image/svg+xml" />\n		<link rel="preload" href="' + assets + '/icons/regular.svg" as="image" type="image/svg+xml" />\n		<link rel="preload" href="' + assets + '/icons/solid.svg" as="image" type="image/svg+xml" />\n		' + head + '\n	</head>\n\n	<body>\n		<div style="display: contents">' + body + "</div>\n	</body>\n</html>\n",
     error: ({ status, message }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<title>' + message + `</title>
@@ -2988,7 +3018,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: "v07bjl"
+  version_hash: "14jmemo"
 };
 async function get_hooks() {
   let handle;
@@ -2996,7 +3026,7 @@ async function get_hooks() {
   let handleError;
   let handleValidationError;
   let init;
-  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./chunks/hooks.server-BJTU7JI4.js'));
+  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./chunks/hooks.server-B7iBt6uC.js'));
   let reroute;
   let transport;
   return {
@@ -3010,6 +3040,22 @@ async function get_hooks() {
   };
 }
 
+const INVALIDATED_PARAM = "x-sveltekit-invalidated";
+const TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
+function stringify(data, transport) {
+  const encoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode]));
+  return stringify$1(data, encoders);
+}
+function parse_remote_arg(string, transport) {
+  if (!string) return void 0;
+  const json_string = text_decoder.decode(
+    // no need to add back `=` characters, atob can handle it
+    base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))
+  );
+  const decoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.decode]));
+  return parse(json_string, decoders);
+}
+
 var setCookie = {exports: {}};
 
 var hasRequiredSetCookie;
@@ -3370,10 +3416,10 @@ function static_error_page(options2, status, message) {
     status
   });
 }
-async function handle_fatal_error(event, options2, error2) {
+async function handle_fatal_error(event, state, options2, error2) {
   error2 = error2 instanceof HttpError ? error2 : coalesce_to_error(error2);
   const status = get_status(error2);
-  const body2 = await handle_error_and_jsonify(event, options2, error2);
+  const body2 = await handle_error_and_jsonify(event, state, options2, error2);
   const type = negotiate(event.request.headers.get("accept") || "text/html", [
     "application/json",
     "text/html"
@@ -3385,14 +3431,14 @@ async function handle_fatal_error(event, options2, error2) {
   }
   return static_error_page(options2, status, body2.message);
 }
-async function handle_error_and_jsonify(event, options2, error2) {
+async function handle_error_and_jsonify(event, state, options2, error2) {
   if (error2 instanceof HttpError) {
     return error2.body;
   }
   const status = get_status(error2);
   const message = get_message(error2);
-  return await with_event(
-    event,
+  return await with_request_store(
+    { event, state },
     () => options2.hooks.handleError({ error: error2, event, status, message })
   ) ?? { message };
 }
@@ -3431,7 +3477,14 @@ function serialize_uses(node) {
 function has_prerendered_path(manifest, pathname) {
   return manifest._.prerendered_routes.has(pathname) || pathname.at(-1) === "/" && manifest._.prerendered_routes.has(pathname.slice(0, -1));
 }
-async function render_endpoint(event, mod, state) {
+function get_node_type(node_id) {
+  const parts = node_id?.split("/");
+  const filename = parts?.at(-1);
+  if (!filename) return "unknown";
+  const dot_parts = filename.split(".");
+  return dot_parts.slice(0, -1).join(".");
+}
+async function render_endpoint(event, event_state, mod, state) {
   const method = (
     /** @type {import('types').HttpMethod} */
     event.request.method
@@ -3455,8 +3508,8 @@ async function render_endpoint(event, mod, state) {
     }
   }
   try {
-    const response = await with_event(
-      event,
+    const response = await with_request_store(
+      { event, state: event_state },
       () => handler(
         /** @type {import('@sveltejs/kit').RequestEvent<Record<string, any>>} */
         event
@@ -3538,6 +3591,51 @@ function add_resolution_suffix(pathname) {
 function strip_resolution_suffix(pathname) {
   return pathname.slice(0, -ROUTE_SUFFIX.length);
 }
+const noop_span = {
+  spanContext() {
+    return noop_span_context;
+  },
+  setAttribute() {
+    return this;
+  },
+  setAttributes() {
+    return this;
+  },
+  addEvent() {
+    return this;
+  },
+  setStatus() {
+    return this;
+  },
+  updateName() {
+    return this;
+  },
+  end() {
+    return this;
+  },
+  isRecording() {
+    return false;
+  },
+  recordException() {
+    return this;
+  },
+  addLink() {
+    return this;
+  },
+  addLinks() {
+    return this;
+  }
+};
+const noop_span_context = {
+  traceId: "",
+  spanId: "",
+  traceFlags: 0
+};
+async function record_span({ name, attributes, fn }) {
+  {
+    return fn(noop_span);
+  }
+}
 function is_action_json_request(event) {
   const accept = negotiate(event.request.headers.get("accept") ?? "*/*", [
     "application/json",
@@ -3545,7 +3643,7 @@ function is_action_json_request(event) {
   ]);
   return accept === "application/json" && event.request.method === "POST";
 }
-async function handle_action_json_request(event, options2, server) {
+async function handle_action_json_request(event, event_state, options2, server) {
   const actions = server?.actions;
   if (!actions) {
     const no_actions_error = new SvelteKitError(
@@ -3556,7 +3654,7 @@ async function handle_action_json_request(event, options2, server) {
     return action_json(
       {
         type: "error",
-        error: await handle_error_and_jsonify(event, options2, no_actions_error)
+        error: await handle_error_and_jsonify(event, event_state, options2, no_actions_error)
       },
       {
         status: no_actions_error.status,
@@ -3570,7 +3668,7 @@ async function handle_action_json_request(event, options2, server) {
   }
   check_named_default_separate(actions);
   try {
-    const data = await call_action(event, actions);
+    const data = await call_action(event, event_state, actions);
     if (false) ;
     if (data instanceof ActionFailure) {
       return action_json({
@@ -3607,7 +3705,12 @@ async function handle_action_json_request(event, options2, server) {
     return action_json(
       {
         type: "error",
-        error: await handle_error_and_jsonify(event, options2, check_incorrect_fail_use(err))
+        error: await handle_error_and_jsonify(
+          event,
+          event_state,
+          options2,
+          check_incorrect_fail_use(err)
+        )
       },
       {
         status: get_status(err)
@@ -3631,7 +3734,7 @@ function action_json(data, init2) {
 function is_action_request(event) {
   return event.request.method === "POST";
 }
-async function handle_action_request(event, server) {
+async function handle_action_request(event, event_state, server) {
   const actions = server?.actions;
   if (!actions) {
     event.setHeaders({
@@ -3650,7 +3753,7 @@ async function handle_action_request(event, server) {
   }
   check_named_default_separate(actions);
   try {
-    const data = await call_action(event, actions);
+    const data = await call_action(event, event_state, actions);
     if (false) ;
     if (data instanceof ActionFailure) {
       return {
@@ -3688,7 +3791,7 @@ function check_named_default_separate(actions) {
     );
   }
 }
-async function call_action(event, actions) {
+async function call_action(event, event_state, actions) {
   const url = new URL(event.request.url);
   let name = "default";
   for (const param of url.searchParams) {
@@ -3713,7 +3816,26 @@ async function call_action(event, actions) {
       )}`
     );
   }
-  return with_event(event, () => action(event));
+  return record_span({
+    name: "sveltekit.form_action",
+    attributes: {
+      "http.route": event.route.id || "unknown"
+    },
+    fn: async (current) => {
+      const traced_event = merge_tracing(event, current);
+      const result = await with_request_store(
+        { event: traced_event, state: event_state },
+        () => action(traced_event)
+      );
+      if (result instanceof ActionFailure) {
+        current.setAttributes({
+          "sveltekit.form_action.result.type": "failure",
+          "sveltekit.form_action.result.status": result.status
+        });
+      }
+      return result;
+    }
+  });
 }
 function uneval_action_response(data, route_id, transport) {
   const replacer = (thing) => {
@@ -3753,30 +3875,7 @@ function try_serialize(data, fn, route_id) {
     throw error2;
   }
 }
-function b64_encode(buffer) {
-  if (globalThis.Buffer) {
-    return Buffer.from(buffer).toString("base64");
-  }
-  const little_endian = new Uint8Array(new Uint16Array([1]).buffer)[0] > 0;
-  return btoa(
-    new TextDecoder(little_endian ? "utf-16le" : "utf-16be").decode(
-      new Uint16Array(new Uint8Array(buffer))
-    )
-  );
-}
-function get_relative_path(from, to) {
-  const from_parts = from.split(/[/\\]/);
-  const to_parts = to.split(/[/\\]/);
-  from_parts.pop();
-  while (from_parts[0] === to_parts[0]) {
-    from_parts.shift();
-    to_parts.shift();
-  }
-  let i = from_parts.length;
-  while (i--) from_parts[i] = "..";
-  return from_parts.concat(to_parts).join("/");
-}
-async function load_server_data({ event, state, node, parent }) {
+async function load_server_data({ event, event_state, state, node, parent }) {
   if (!node?.server) return null;
   let is_tracking = true;
   const uses = {
@@ -3808,67 +3907,72 @@ async function load_server_data({ event, state, node, parent }) {
   if (state.prerendering) {
     disable_search(url);
   }
-  let done = false;
-  const result = await with_event(
-    event,
-    () => load.call(null, {
-      ...event,
-      fetch: (info, init2) => {
-        const url2 = new URL(info instanceof Request ? info.url : info, event.url);
-        if (DEV && done && !uses.dependencies.has(url2.href)) ;
-        return event.fetch(info, init2);
-      },
-      /** @param {string[]} deps */
-      depends: (...deps) => {
-        for (const dep of deps) {
-          const { href } = new URL(dep, event.url);
-          if (DEV) ;
-          uses.dependencies.add(href);
-        }
-      },
-      params: new Proxy(event.params, {
-        get: (target, key2) => {
-          if (DEV && done && typeof key2 === "string" && !uses.params.has(key2)) ;
-          if (is_tracking) {
-            uses.params.add(key2);
-          }
-          return target[
-            /** @type {string} */
-            key2
-          ];
-        }
-      }),
-      parent: async () => {
-        if (DEV && done && !uses.parent) ;
-        if (is_tracking) {
-          uses.parent = true;
-        }
-        return parent();
-      },
-      route: new Proxy(event.route, {
-        get: (target, key2) => {
-          if (DEV && done && typeof key2 === "string" && !uses.route) ;
-          if (is_tracking) {
-            uses.route = true;
+  const result = await record_span({
+    name: "sveltekit.load",
+    attributes: {
+      "sveltekit.load.node_id": node.server_id || "unknown",
+      "sveltekit.load.node_type": get_node_type(node.server_id),
+      "http.route": event.route.id || "unknown"
+    },
+    fn: async (current) => {
+      const traced_event = merge_tracing(event, current);
+      const result2 = await with_request_store(
+        { event: traced_event, state: event_state },
+        () => load.call(null, {
+          ...traced_event,
+          fetch: (info, init2) => {
+            new URL(info instanceof Request ? info.url : info, event.url);
+            return event.fetch(info, init2);
+          },
+          /** @param {string[]} deps */
+          depends: (...deps) => {
+            for (const dep of deps) {
+              const { href } = new URL(dep, event.url);
+              uses.dependencies.add(href);
+            }
+          },
+          params: new Proxy(event.params, {
+            get: (target, key2) => {
+              if (is_tracking) {
+                uses.params.add(key2);
+              }
+              return target[
+                /** @type {string} */
+                key2
+              ];
+            }
+          }),
+          parent: async () => {
+            if (is_tracking) {
+              uses.parent = true;
+            }
+            return parent();
+          },
+          route: new Proxy(event.route, {
+            get: (target, key2) => {
+              if (is_tracking) {
+                uses.route = true;
+              }
+              return target[
+                /** @type {'id'} */
+                key2
+              ];
+            }
+          }),
+          url,
+          untrack(fn) {
+            is_tracking = false;
+            try {
+              return fn();
+            } finally {
+              is_tracking = true;
+            }
           }
-          return target[
-            /** @type {'id'} */
-            key2
-          ];
-        }
-      }),
-      url,
-      untrack(fn) {
-        is_tracking = false;
-        try {
-          return fn();
-        } finally {
-          is_tracking = true;
-        }
-      }
-    })
-  );
-  done = true;
+        })
+      );
+      return result2;
+    }
+  });
   return {
     type: "data",
     data: result ?? null,
@@ -3878,6 +3982,7 @@ async function load_server_data({ event, state, node, parent }) {
 }
 async function load_data({
   event,
+  event_state,
   fetched,
   node,
   parent,
@@ -3891,21 +3996,33 @@ async function load_data({
   if (!load) {
     return server_data_node?.data ?? null;
   }
-  const result = await with_event(
-    event,
-    () => load.call(null, {
-      url: event.url,
-      params: event.params,
-      data: server_data_node?.data ?? null,
-      route: event.route,
-      fetch: create_universal_fetch(event, state, fetched, csr, resolve_opts),
-      setHeaders: event.setHeaders,
-      depends: () => {
-      },
-      parent,
-      untrack: (fn) => fn()
-    })
-  );
+  const result = await record_span({
+    name: "sveltekit.load",
+    attributes: {
+      "sveltekit.load.node_id": node.universal_id || "unknown",
+      "sveltekit.load.node_type": get_node_type(node.universal_id),
+      "http.route": event.route.id || "unknown"
+    },
+    fn: async (current) => {
+      const traced_event = merge_tracing(event, current);
+      return await with_request_store(
+        { event: traced_event, state: event_state },
+        () => load.call(null, {
+          url: event.url,
+          params: event.params,
+          data: server_data_node?.data ?? null,
+          route: event.route,
+          fetch: create_universal_fetch(event, state, fetched, csr, resolve_opts),
+          setHeaders: event.setHeaders,
+          depends: () => {
+          },
+          parent,
+          untrack: (fn) => fn(),
+          tracing: traced_event.tracing
+        })
+      );
+    }
+  });
   return result ?? null;
 }
 function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
@@ -3938,6 +4055,7 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
         }
       }
     }
+    let teed_body;
     const proxy = new Proxy(response, {
       get(response2, key2, _receiver) {
         async function push_fetched(body2, is_b64) {
@@ -3960,14 +4078,38 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
             is_b64
           });
         }
+        if (key2 === "body") {
+          if (response2.body === null) {
+            return null;
+          }
+          if (teed_body) {
+            return teed_body;
+          }
+          const [a, b] = response2.body.tee();
+          void (async () => {
+            let result = new Uint8Array();
+            for await (const chunk of a) {
+              const combined = new Uint8Array(result.length + chunk.length);
+              combined.set(result, 0);
+              combined.set(chunk, result.length);
+              result = combined;
+            }
+            if (dependency) {
+              dependency.body = new Uint8Array(result);
+            }
+            void push_fetched(base64_encode(result), true);
+          })();
+          return teed_body = b;
+        }
         if (key2 === "arrayBuffer") {
           return async () => {
             const buffer = await response2.arrayBuffer();
+            const bytes = new Uint8Array(buffer);
             if (dependency) {
-              dependency.body = new Uint8Array(buffer);
+              dependency.body = bytes;
             }
             if (buffer instanceof ArrayBuffer) {
-              await push_fetched(b64_encode(buffer), true);
+              await push_fetched(base64_encode(bytes), true);
             }
             return buffer;
           };
@@ -4021,13 +4163,12 @@ function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
 async function stream_to_string(stream) {
   let result = "";
   const reader = stream.getReader();
-  const decoder = new TextDecoder();
   while (true) {
     const { done, value } = await reader.read();
     if (done) {
       break;
     }
-    result += decoder.decode(value);
+    result += text_decoder.decode(value);
   }
   return result;
 }
@@ -4101,7 +4242,6 @@ function serialize_data(fetched, filter, prerendering2 = false) {
   return `<script ${attrs.join(" ")}>${safe_payload}<\/script>`;
 }
 const s = JSON.stringify;
-const encoder$2 = new TextEncoder();
 function sha256(data) {
   if (!key[0]) precompute();
   const out = init.slice(0);
@@ -4148,7 +4288,7 @@ function sha256(data) {
   }
   const bytes = new Uint8Array(out.buffer);
   reverse_endianness(bytes);
-  return base64(bytes);
+  return btoa(String.fromCharCode(...bytes));
 }
 const init = new Uint32Array(8);
 const key = new Uint32Array(64);
@@ -4187,7 +4327,7 @@ function reverse_endianness(bytes) {
   }
 }
 function encode(str) {
-  const encoded = encoder$2.encode(str);
+  const encoded = text_encoder.encode(str);
   const length = encoded.length * 8;
   const size = 512 * Math.ceil((length + 65) / 512);
   const bytes = new Uint8Array(size / 8);
@@ -4199,34 +4339,10 @@ function encode(str) {
   words[words.length - 1] = length;
   return words;
 }
-const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
-function base64(bytes) {
-  const l = bytes.length;
-  let result = "";
-  let i;
-  for (i = 2; i < l; i += 3) {
-    result += chars[bytes[i - 2] >> 2];
-    result += chars[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-    result += chars[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
-    result += chars[bytes[i] & 63];
-  }
-  if (i === l + 1) {
-    result += chars[bytes[i - 2] >> 2];
-    result += chars[(bytes[i - 2] & 3) << 4];
-    result += "==";
-  }
-  if (i === l) {
-    result += chars[bytes[i - 2] >> 2];
-    result += chars[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-    result += chars[(bytes[i - 1] & 15) << 2];
-    result += "=";
-  }
-  return result;
-}
 const array = new Uint8Array(16);
 function generate_nonce() {
   crypto.getRandomValues(array);
-  return base64(array);
+  return btoa(String.fromCharCode(...array));
 }
 const quoted = /* @__PURE__ */ new Set([
   "self",
@@ -4607,7 +4723,6 @@ const updated = {
   ...readable(false),
   check: () => false
 };
-const encoder$1 = new TextEncoder();
 async function render_response({
   branch,
   fetched,
@@ -4618,6 +4733,7 @@ async function render_response({
   status,
   error: error2 = null,
   event,
+  event_state,
   resolve_opts,
   action_result
 }) {
@@ -4700,7 +4816,10 @@ async function render_response({
     };
     {
       try {
-        rendered = with_event(event, () => options2.root.render(props, render_opts));
+        rendered = with_request_store(
+          { event, state: event_state },
+          () => options2.root.render(props, render_opts)
+        );
       } finally {
         reset();
       }
@@ -4767,6 +4886,7 @@ async function render_response({
   const global = `__sveltekit_${options2.version_hash}`;
   const { data, chunks } = get_data(
     event,
+    event_state,
     options2,
     branch.map((b) => b.server_data),
     csp,
@@ -4833,7 +4953,7 @@ async function render_response({
 							try_to_resolve();
 						}`);
     }
-    const { remote_data } = get_event_state(event);
+    const { remote_data } = event_state;
     if (remote_data) {
       const remote = {};
       for (const key2 in remote_data) {
@@ -4913,7 +5033,11 @@ ${indent}}`);
       blocks.push(boot);
     }
     if (options2.service_worker) {
-      const opts = "";
+      let opts = "";
+      if (options2.service_worker_options != null) {
+        const service_worker_options = { ...options2.service_worker_options };
+        opts = `, ${s(service_worker_options)}`;
+      }
       blocks.push(`if ('serviceWorker' in navigator) {
 						addEventListener('load', function () {
 							navigator.serviceWorker.register('${prefixed("service-worker.js")}'${opts});
@@ -4983,9 +5107,9 @@ ${indent}}`);
   }) : new Response(
     new ReadableStream({
       async start(controller) {
-        controller.enqueue(encoder$1.encode(transformed + "\n"));
+        controller.enqueue(text_encoder.encode(transformed + "\n"));
         for await (const chunk of chunks) {
-          controller.enqueue(encoder$1.encode(chunk));
+          controller.enqueue(text_encoder.encode(chunk));
         }
         controller.close();
       },
@@ -4996,7 +5120,7 @@ ${indent}}`);
     }
   );
 }
-function get_data(event, options2, nodes, csp, global) {
+function get_data(event, event_state, options2, nodes, csp, global) {
   let promise_id = 1;
   let count = 0;
   const { iterator, push, done } = create_async_iterator();
@@ -5010,7 +5134,7 @@ function get_data(event, options2, nodes, csp, global) {
       ).catch(
         /** @param {any} error */
         async (error2) => ({
-          error: await handle_error_and_jsonify(event, options2, error2)
+          error: await handle_error_and_jsonify(event, event_state, options2, error2)
         })
       ).then(
         /**
@@ -5024,6 +5148,7 @@ function get_data(event, options2, nodes, csp, global) {
           } catch {
             error2 = await handle_error_and_jsonify(
               event,
+              event_state,
               options2,
               new Error(`Failed to serialize promise while rendering ${event.route.id}`)
             );
@@ -5157,6 +5282,7 @@ class PageNodes {
 }
 async function respond_with_error({
   event,
+  event_state,
   options: options2,
   manifest,
   state,
@@ -5183,6 +5309,7 @@ async function respond_with_error({
       state.error = true;
       const server_data_promise = load_server_data({
         event,
+        event_state,
         state,
         node: default_layout,
         // eslint-disable-next-line @typescript-eslint/require-await
@@ -5191,6 +5318,7 @@ async function respond_with_error({
       const server_data = await server_data_promise;
       const data = await load_data({
         event,
+        event_state,
         fetched,
         node: default_layout,
         // eslint-disable-next-line @typescript-eslint/require-await
@@ -5223,10 +5351,11 @@ async function respond_with_error({
         csr
       },
       status,
-      error: await handle_error_and_jsonify(event, options2, error2),
+      error: await handle_error_and_jsonify(event, event_state, options2, error2),
       branch,
       fetched,
       event,
+      event_state,
       resolve_opts
     });
   } catch (e) {
@@ -5236,7 +5365,7 @@ async function respond_with_error({
     return static_error_page(
       options2,
       get_status(e),
-      (await handle_error_and_jsonify(event, options2, e)).message
+      (await handle_error_and_jsonify(event, event_state, options2, e)).message
     );
   }
 }
@@ -5249,8 +5378,7 @@ function once(fn) {
     return result = fn();
   };
 }
-const encoder = new TextEncoder();
-async function render_data(event, route, options2, manifest, state, invalidated_data_nodes, trailing_slash) {
+async function render_data(event, event_state, route, options2, manifest, state, invalidated_data_nodes, trailing_slash) {
   if (!route.page) {
     return new Response(void 0, {
       status: 404
@@ -5277,6 +5405,7 @@ async function render_data(event, route, options2, manifest, state, invalidated_
           const node = n == void 0 ? n : await manifest._.nodes[n]();
           return load_server_data({
             event: new_event,
+            event_state,
             state,
             node,
             parent: async () => {
@@ -5322,23 +5451,23 @@ async function render_data(event, route, options2, manifest, state, invalidated_
             /** @type {import('types').ServerErrorNode} */
             {
               type: "error",
-              error: await handle_error_and_jsonify(event, options2, error2),
+              error: await handle_error_and_jsonify(event, event_state, options2, error2),
               status: error2 instanceof HttpError || error2 instanceof SvelteKitError ? error2.status : void 0
             }
           );
         })
       )
     );
-    const { data, chunks } = get_data_json(event, options2, nodes);
+    const { data, chunks } = get_data_json(event, event_state, options2, nodes);
     if (!chunks) {
       return json_response(data);
     }
     return new Response(
       new ReadableStream({
         async start(controller) {
-          controller.enqueue(encoder.encode(data));
+          controller.enqueue(text_encoder.encode(data));
           for await (const chunk of chunks) {
-            controller.enqueue(encoder.encode(chunk));
+            controller.enqueue(text_encoder.encode(chunk));
           }
           controller.close();
         },
@@ -5358,7 +5487,7 @@ async function render_data(event, route, options2, manifest, state, invalidated_
     if (error2 instanceof Redirect) {
       return redirect_json_response(error2);
     } else {
-      return json_response(await handle_error_and_jsonify(event, options2, error2), 500);
+      return json_response(await handle_error_and_jsonify(event, event_state, options2, error2), 500);
     }
   }
 }
@@ -5380,7 +5509,7 @@ function redirect_json_response(redirect) {
     }
   );
 }
-function get_data_json(event, options2, nodes) {
+function get_data_json(event, event_state, options2, nodes) {
   let promise_id = 1;
   let count = 0;
   const { iterator, push, done } = create_async_iterator();
@@ -5400,6 +5529,7 @@ function get_data_json(event, options2, nodes) {
             key2 = "error";
             return handle_error_and_jsonify(
               event,
+              event_state,
               options2,
               /** @type {any} */
               e
@@ -5414,6 +5544,7 @@ function get_data_json(event, options2, nodes) {
             } catch {
               const error2 = await handle_error_and_jsonify(
                 event,
+                event_state,
                 options2,
                 new Error(`Failed to serialize promise while rendering ${event.route.id}`)
               );
@@ -5454,7 +5585,20 @@ function get_data_json(event, options2, nodes) {
     ));
   }
 }
-async function handle_remote_call(event, options2, manifest, id) {
+async function handle_remote_call(event, state, options2, manifest, id) {
+  return record_span({
+    name: "sveltekit.remote.call",
+    attributes: {},
+    fn: (current) => {
+      const traced_event = merge_tracing(event, current);
+      return with_request_store(
+        { event: traced_event, state },
+        () => handle_remote_call_internal(traced_event, state, options2, manifest, id)
+      );
+    }
+  });
+}
+async function handle_remote_call_internal(event, state, options2, manifest, id) {
   const [hash2, name, prerender_args] = id.split("/");
   const remotes = manifest._.remotes;
   if (!remotes[hash2]) error(404);
@@ -5463,6 +5607,10 @@ async function handle_remote_call(event, options2, manifest, id) {
   if (!fn) error(404);
   const info = fn.__;
   const transport = options2.hooks.transport;
+  event.tracing.current.setAttributes({
+    "sveltekit.remote.call.type": info.type,
+    "sveltekit.remote.call.name": info.name
+  });
   let form_client_refreshes;
   try {
     if (info.type === "form") {
@@ -5482,21 +5630,15 @@ async function handle_remote_call(event, options2, manifest, id) {
       );
       form_data.delete("sveltekit:remote_refreshes");
       const fn2 = info.fn;
-      const data2 = await with_event(event, () => fn2(form_data));
+      const data2 = await with_request_store({ event, state }, () => fn2(form_data));
       return json(
         /** @type {RemoteFunctionResponse} */
         {
           type: "result",
           result: stringify(data2, transport),
-          refreshes: stringify(
-            {
-              ...get_event_state(event).refreshes,
-              ...await apply_client_refreshes(
-                /** @type {string[]} */
-                form_client_refreshes
-              )
-            },
-            transport
+          refreshes: await serialize_refreshes(
+            /** @type {string[]} */
+            form_client_refreshes
           )
         }
       );
@@ -5504,14 +5646,13 @@ async function handle_remote_call(event, options2, manifest, id) {
     if (info.type === "command") {
       const { payload: payload2, refreshes } = await event.request.json();
       const arg = parse_remote_arg(payload2, transport);
-      const data2 = await with_event(event, () => fn(arg));
-      const refreshed = await apply_client_refreshes(refreshes);
+      const data2 = await with_request_store({ event, state }, () => fn(arg));
       return json(
         /** @type {RemoteFunctionResponse} */
         {
           type: "result",
           result: stringify(data2, transport),
-          refreshes: stringify({ ...get_event_state(event).refreshes, ...refreshed }, transport)
+          refreshes: await serialize_refreshes(refreshes)
         }
       );
     }
@@ -5520,7 +5661,10 @@ async function handle_remote_call(event, options2, manifest, id) {
       // new URL(...) necessary because we're hiding the URL from the user in the event object
       new URL(event.request.url).searchParams.get("payload")
     );
-    const data = await with_event(event, () => fn(parse_remote_arg(payload, transport)));
+    const data = await with_request_store(
+      { event, state },
+      () => fn(parse_remote_arg(payload, transport))
+    );
     return json(
       /** @type {RemoteFunctionResponse} */
       {
@@ -5530,22 +5674,17 @@ async function handle_remote_call(event, options2, manifest, id) {
     );
   } catch (error2) {
     if (error2 instanceof Redirect) {
-      const refreshes = {
-        ...get_event_state(event).refreshes ?? {},
-        // could be set by form actions
-        ...await apply_client_refreshes(form_client_refreshes ?? [])
-      };
       return json({
         type: "redirect",
         location: error2.location,
-        refreshes: Object.keys(refreshes).length > 0 ? stringify(refreshes, transport) : void 0
+        refreshes: await serialize_refreshes(form_client_refreshes ?? [])
       });
     }
     return json(
       /** @type {RemoteFunctionResponse} */
       {
         type: "error",
-        error: await handle_error_and_jsonify(event, options2, error2),
+        error: await handle_error_and_jsonify(event, state, options2, error2),
         status: error2 instanceof HttpError || error2 instanceof SvelteKitError ? error2.status : 500
       },
       {
@@ -5555,23 +5694,46 @@ async function handle_remote_call(event, options2, manifest, id) {
       }
     );
   }
-  async function apply_client_refreshes(refreshes) {
-    return Object.fromEntries(
-      await Promise.all(
-        refreshes.map(async (key2) => {
-          const [hash3, name2, payload] = key2.split("/");
-          const loader = manifest._.remotes[hash3];
-          if (!loader) error(400, "Bad Request");
-          const module2 = await loader();
-          const fn2 = module2[name2];
-          if (!fn2) error(400, "Bad Request");
-          return [key2, await with_event(event, () => fn2(parse_remote_arg(payload, transport)))];
-        })
+  async function serialize_refreshes(client_refreshes) {
+    const refreshes = {
+      ...state.refreshes,
+      ...Object.fromEntries(
+        await Promise.all(
+          client_refreshes.map(async (key2) => {
+            const [hash3, name2, payload] = key2.split("/");
+            const loader = manifest._.remotes[hash3];
+            if (!loader) error(400, "Bad Request");
+            const module2 = await loader();
+            const fn2 = module2[name2];
+            if (!fn2) error(400, "Bad Request");
+            return [
+              key2,
+              await with_request_store(
+                { event, state },
+                () => fn2(parse_remote_arg(payload, transport))
+              )
+            ];
+          })
+        )
       )
-    );
-  }
+    };
+    return Object.keys(refreshes).length > 0 ? stringify(refreshes, transport) : void 0;
+  }
+}
+async function handle_remote_form_post(event, state, manifest, id) {
+  return record_span({
+    name: "sveltekit.remote.form.post",
+    attributes: {},
+    fn: (current) => {
+      const traced_event = merge_tracing(event, current);
+      return with_request_store(
+        { event: traced_event, state },
+        () => handle_remote_form_post_internal(traced_event, state, manifest, id)
+      );
+    }
+  });
 }
-async function handle_remote_form_post(event, manifest, id) {
+async function handle_remote_form_post_internal(event, state, manifest, id) {
   const [hash2, name, action_id] = id.split("/");
   const remotes = manifest._.remotes;
   const module = await remotes[hash2]?.();
@@ -5595,7 +5757,7 @@ async function handle_remote_form_post(event, manifest, id) {
     };
   }
   if (action_id) {
-    form = with_event(event, () => form.for(JSON.parse(action_id)));
+    form = with_request_store({ event, state }, () => form.for(JSON.parse(action_id)));
   }
   try {
     const form_data = await event.request.formData();
@@ -5604,7 +5766,7 @@ async function handle_remote_form_post(event, manifest, id) {
       /** @type {any} */
       form.__.fn
     );
-    await with_event(event, () => fn(form_data));
+    await with_request_store({ event, state }, () => fn(form_data));
     return {
       type: "success",
       status: 200
@@ -5631,7 +5793,7 @@ function get_remote_action(url) {
   return url.searchParams.get("/remote");
 }
 const MAX_DEPTH = 10;
-async function render_page(event, page, options2, manifest, state, nodes, resolve_opts) {
+async function render_page(event, event_state, page, options2, manifest, state, nodes, resolve_opts) {
   if (state.depth > MAX_DEPTH) {
     return text(`Not found: ${event.url.pathname}`, {
       status: 404
@@ -5640,7 +5802,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
   }
   if (is_action_json_request(event)) {
     const node = await manifest._.nodes[page.leaf]();
-    return handle_action_json_request(event, options2, node?.server);
+    return handle_action_json_request(event, event_state, options2, node?.server);
   }
   try {
     const leaf_node = (
@@ -5652,9 +5814,9 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
     if (is_action_request(event)) {
       const remote_id = get_remote_action(event.url);
       if (remote_id) {
-        action_result = await handle_remote_form_post(event, manifest, remote_id);
+        action_result = await handle_remote_form_post(event, event_state, manifest, remote_id);
       } else {
-        action_result = await handle_action_request(event, leaf_node.server);
+        action_result = await handle_action_request(event, event_state, leaf_node.server);
       }
       if (action_result?.type === "redirect") {
         return redirect_response(action_result.status, action_result.location);
@@ -5695,6 +5857,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
         status,
         error: null,
         event,
+        event_state,
         options: options2,
         manifest,
         state,
@@ -5714,6 +5877,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
           }
           return await load_server_data({
             event,
+            event_state,
             state,
             node,
             parent: async () => {
@@ -5738,6 +5902,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
         try {
           return await load_data({
             event,
+            event_state,
             fetched,
             node,
             parent: async () => {
@@ -5786,7 +5951,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
             return redirect_response(err.status, err.location);
           }
           const status2 = get_status(err);
-          const error2 = await handle_error_and_jsonify(event, options2, err);
+          const error2 = await handle_error_and_jsonify(event, event_state, options2, err);
           while (i--) {
             if (page.errors[i]) {
               const index = (
@@ -5800,6 +5965,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
               const nodes2 = new PageNodes(layouts.map((layout) => layout.node));
               return await render_response({
                 event,
+                event_state,
                 options: options2,
                 manifest,
                 state,
@@ -5828,6 +5994,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
     if (state.prerendering && should_prerender_data) {
       let { data, chunks } = get_data_json(
         event,
+        event_state,
         options2,
         branch.map((node) => node?.server_data)
       );
@@ -5843,6 +6010,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
     }
     return await render_response({
       event,
+      event_state,
       options: options2,
       manifest,
       state,
@@ -5860,6 +6028,7 @@ async function render_page(event, page, options2, manifest, state, nodes, resolv
   } catch (e) {
     return await respond_with_error({
       event,
+      event_state,
       options: options2,
       manifest,
       state,
@@ -5966,8 +6135,8 @@ function get_cookies(request, url) {
       const cookie = new_cookies[key2];
       if (!domain_matches(destination.hostname, cookie.options.domain)) continue;
       if (!path_matches(destination.pathname, cookie.options.path)) continue;
-      const encoder2 = cookie.options.encode || encodeURIComponent;
-      combined_cookies[cookie.name] = encoder2(cookie.value);
+      const encoder = cookie.options.encode || encodeURIComponent;
+      combined_cookies[cookie.name] = encoder(cookie.value);
     }
     if (header2) {
       const parsed = parse$1(header2, { decode: (value) => value });
@@ -6176,7 +6345,8 @@ const default_filter = () => false;
 const default_preload = ({ type }) => type === "js" || type === "css";
 const page_methods = /* @__PURE__ */ new Set(["GET", "HEAD", "POST"]);
 const allowed_page_methods = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
-async function respond(request, options2, manifest, state) {
+const respond = propagate_context(internal_respond);
+async function internal_respond(request, options2, manifest, state) {
   const url = new URL(request.url);
   const is_route_resolution_request = has_resolution_suffix(url.pathname);
   const is_data_request = has_data_suffix(url.pathname);
@@ -6220,8 +6390,15 @@ async function respond(request, options2, manifest, state) {
     request,
     url
   );
+  const event_state = {
+    prerendering: state.prerendering,
+    transport: options2.hooks.transport,
+    handleValidationError: options2.hooks.handleValidationError,
+    tracing: {
+      record_span
+    }
+  };
   const event = {
-    [EVENT_STATE]: create_event_state(state, options2),
     cookies,
     // @ts-expect-error `fetch` needs to be created after the `event` itself
     fetch: null,
@@ -6396,34 +6573,66 @@ async function respond(request, options2, manifest, state) {
     if (state.prerendering && !state.prerendering.fallback && !state.prerendering.inside_reroute) {
       disable_search(url);
     }
-    const response = await with_event(
-      event,
-      () => options2.hooks.handle({
-        event,
-        resolve: (event2, opts) => (
-          // counter-intuitively, we need to clear the event, so that it's not
-          // e.g. accessible when loading modules needed to handle the request
-          with_event(
-            null,
-            () => resolve2(event2, page_nodes, opts).then((response2) => {
-              for (const key2 in headers2) {
-                const value = headers2[key2];
-                response2.headers.set(
-                  key2,
-                  /** @type {string} */
-                  value
-                );
-              }
-              add_cookies_to_headers(response2.headers, Object.values(new_cookies));
-              if (state.prerendering && event2.route.id !== null) {
-                response2.headers.set("x-sveltekit-routeid", encodeURI(event2.route.id));
-              }
-              return response2;
-            })
-          )
-        )
-      })
-    );
+    const response = await record_span({
+      name: "sveltekit.handle.root",
+      attributes: {
+        "http.route": event.route.id || "unknown",
+        "http.method": event.request.method,
+        "http.url": event.url.href,
+        "sveltekit.is_data_request": is_data_request,
+        "sveltekit.is_sub_request": event.isSubRequest
+      },
+      fn: async (root_span) => {
+        const traced_event = {
+          ...event,
+          tracing: {
+            enabled: false,
+            root: root_span,
+            current: root_span
+          }
+        };
+        return await with_request_store(
+          { event: traced_event, state: event_state },
+          () => options2.hooks.handle({
+            event: traced_event,
+            resolve: (event2, opts) => {
+              return record_span({
+                name: "sveltekit.resolve",
+                attributes: {
+                  "http.route": event2.route.id || "unknown"
+                },
+                fn: (resolve_span) => {
+                  return with_request_store(
+                    null,
+                    () => resolve2(merge_tracing(event2, resolve_span), page_nodes, opts).then(
+                      (response2) => {
+                        for (const key2 in headers2) {
+                          const value = headers2[key2];
+                          response2.headers.set(
+                            key2,
+                            /** @type {string} */
+                            value
+                          );
+                        }
+                        add_cookies_to_headers(response2.headers, Object.values(new_cookies));
+                        if (state.prerendering && event2.route.id !== null) {
+                          response2.headers.set("x-sveltekit-routeid", encodeURI(event2.route.id));
+                        }
+                        resolve_span.setAttributes({
+                          "http.response.status_code": response2.status,
+                          "http.response.body.size": response2.headers.get("content-length") || "unknown"
+                        });
+                        return response2;
+                      }
+                    )
+                  );
+                }
+              });
+            }
+          })
+        );
+      }
+    });
     if (response.status === 200 && response.headers.has("etag")) {
       let if_none_match_value = request.headers.get("if-none-match");
       if (if_none_match_value?.startsWith('W/"')) {
@@ -6469,7 +6678,7 @@ async function respond(request, options2, manifest, state) {
       add_cookies_to_headers(response.headers, Object.values(new_cookies));
       return response;
     }
-    return await handle_fatal_error(event, options2, e);
+    return await handle_fatal_error(event, event_state, options2, e);
   }
   async function resolve2(event2, page_nodes, opts) {
     try {
@@ -6483,6 +6692,7 @@ async function respond(request, options2, manifest, state) {
       if (options2.hash_routing || state.prerendering?.fallback) {
         return await render_response({
           event: event2,
+          event_state,
           options: options2,
           manifest,
           state,
@@ -6495,7 +6705,7 @@ async function respond(request, options2, manifest, state) {
         });
       }
       if (remote_id) {
-        return await handle_remote_call(event2, options2, manifest, remote_id);
+        return await handle_remote_call(event2, event_state, options2, manifest, remote_id);
       }
       if (route) {
         const method = (
@@ -6506,6 +6716,7 @@ async function respond(request, options2, manifest, state) {
         if (is_data_request) {
           response = await render_data(
             event2,
+            event_state,
             route,
             options2,
             manifest,
@@ -6514,13 +6725,14 @@ async function respond(request, options2, manifest, state) {
             trailing_slash
           );
         } else if (route.endpoint && (!route.page || is_endpoint_request(event2))) {
-          response = await render_endpoint(event2, await route.endpoint(), state);
+          response = await render_endpoint(event2, event_state, await route.endpoint(), state);
         } else if (route.page) {
           if (!page_nodes) {
             throw new Error("page_nodes not found. This should never happen");
           } else if (page_methods.has(method)) {
             response = await render_page(
               event2,
+              event_state,
               route.page,
               options2,
               manifest,
@@ -6583,6 +6795,7 @@ async function respond(request, options2, manifest, state) {
         if (DEV && event2.url.pathname === "/.well-known/appspecific/com.chrome.devtools.json") ;
         return await respond_with_error({
           event: event2,
+          event_state,
           options: options2,
           manifest,
           state,
@@ -6596,7 +6809,7 @@ async function respond(request, options2, manifest, state) {
       }
       return await fetch(request);
     } catch (e) {
-      return await handle_fatal_error(event2, options2, e);
+      return await handle_fatal_error(event2, event_state, options2, e);
     } finally {
       event2.cookies.set = () => {
         throw new Error("Cannot use `cookies.set(...)` after the response has been generated");
@@ -6614,6 +6827,13 @@ function load_page_nodes(page, manifest) {
     manifest._.nodes[page.leaf]()
   ]);
 }
+function propagate_context(fn) {
+  return async (req, ...rest) => {
+    {
+      return fn(req, ...rest);
+    }
+  };
+}
 function filter_private_env(env, { public_prefix, private_prefix }) {
   return Object.fromEntries(
     Object.entries(env).filter(