@axium/server 0.25.0 → 0.26.0

package/build/server/index.js

@@ -1,10 +1,9 @@
 import { json, text, error } from '@sveltejs/kit';
 import { Redirect, SvelteKitError, HttpError, ActionFailure } from '@sveltejs/kit/internal';
 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-DlBYhQz7.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, S as STATE_SYMBOL, b as UNINITIALIZED, D as DERIVED, c as DIRTY, d as CLEAN, M as MAYBE_DIRTY, e as DISCONNECTED, I as INERT, f as EFFECT, A as ASYNC, B as BLOCK_EFFECT, i as is_passive_event, g as BRANCH_EFFECT, R as ROOT_EFFECT, h as DESTROYED, j as REACTION_IS_UPDATING, k as EFFECT_RAN, l as EFFECT_PRESERVED, m as HEAD_EFFECT, n as BOUNDARY_EFFECT, o as EFFECT_TRANSPARENT, p as INSPECT_EFFECT, q as STALE_REACTION, s as HYDRATION_END, t as RENDER_EFFECT, u as HYDRATION_START_ELSE, v as USER_EFFECT } from './chunks/index-DJrm8BZm.js';
+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 { 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, S as STATE_SYMBOL, b as UNINITIALIZED, D as DERIVED, c as DIRTY, d as CLEAN, M as MAYBE_DIRTY, e as DISCONNECTED, I as INERT, B as BOUNDARY_EFFECT, f as EFFECT, g as BLOCK_EFFECT, W as WAS_MARKED, i as is_passive_event, h as BRANCH_EFFECT, R as ROOT_EFFECT, j as DESTROYED, A as ASYNC, k as REACTION_IS_UPDATING, l as EFFECT_RAN, m as EFFECT_PRESERVED, n as EFFECT_TRANSPARENT, o as HEAD_EFFECT, p as EAGER_EFFECT, q as STALE_REACTION, s as HYDRATION_END, t as RENDER_EFFECT, u as HYDRATION_START_ELSE, v as USER_EFFECT } from './chunks/index-CIEcmmdN.js';
 import { s as setContext } from './chunks/context-R2425nfV.js';
-import { parse as parse$1, serialize } from 'cookie';
 
 const DEV = false;
 let base = "";
@@ -699,7 +698,13 @@ function unflatten(parsed, revivers) {
 
 				const reviver = revivers?.[type];
 				if (reviver) {
-					return (hydrated[index] = reviver(hydrate(value[1])));
+					let i = value[1];
+					if (typeof i !== 'number') {
+						// if it's not a number, it was serialized by a builtin reviver
+						// so we need to munge it into the format expected by a custom reviver
+						i = values.push(value[1]) - 1;
+					}
+					return (hydrated[index] = reviver(hydrate(i)));
 				}
 
 				switch (type) {
@@ -1183,6 +1188,7 @@ function set_component_context(context) {
 function push(props, runes = false, fn) {
   component_context = {
     p: component_context,
+    i: false,
     c: null,
     e: null,
     s: props,
@@ -1202,6 +1208,7 @@ function pop(component) {
       create_user_effect(fn);
     }
   }
+  context.i = true;
   component_context = context.p;
   return (
     /** @type {T} */
@@ -1231,7 +1238,6 @@ function flush_tasks() {
     run_micro_tasks();
   }
 }
-const adjustments = /* @__PURE__ */ new WeakMap();
 function handle_error(error) {
   var effect = active_effect;
   if (effect === null) {
@@ -1240,9 +1246,6 @@ function handle_error(error) {
   }
   if ((effect.f & EFFECT_RAN) === 0) {
     if ((effect.f & BOUNDARY_EFFECT) === 0) {
-      if (!effect.parent && error instanceof Error) {
-        apply_adjustments(error);
-      }
       throw error;
     }
     effect.b.error(error);
@@ -1262,31 +1265,17 @@ function invoke_error_boundary(error, effect) {
     }
     effect = effect.parent;
   }
-  if (error instanceof Error) {
-    apply_adjustments(error);
-  }
   throw error;
 }
-function apply_adjustments(error) {
-  const adjusted = adjustments.get(error);
-  if (adjusted) {
-    define_property(error, "message", {
-      value: adjusted.message
-    });
-    define_property(error, "stack", {
-      value: adjusted.stack
-    });
-  }
-}
 const batches = /* @__PURE__ */ new Set();
 let current_batch = null;
 let batch_values = null;
-let effect_pending_updates = /* @__PURE__ */ new Set();
 let queued_root_effects = [];
 let last_scheduled_effect = null;
 let is_flushing = false;
 let is_flushing_sync = false;
 class Batch {
+  committed = false;
   /**
    * The current values of any sources that are updated in this batch
    * They keys of this map are identical to `this.#previous`
@@ -1298,46 +1287,32 @@ class Batch {
    * They keys of this map are identical to `this.#current`
    * @type {Map<Source, any>}
    */
-  #previous = /* @__PURE__ */ new Map();
+  previous = /* @__PURE__ */ new Map();
   /**
    * When the batch is committed (and the DOM is updated), we need to remove old branches
    * and append new ones by calling the functions added inside (if/each/key/etc) blocks
    * @type {Set<() => void>}
    */
-  #callbacks = /* @__PURE__ */ new Set();
+  #commit_callbacks = /* @__PURE__ */ new Set();
+  /**
+   * If a fork is discarded, we need to destroy any effects that are no longer needed
+   * @type {Set<(batch: Batch) => void>}
+   */
+  #discard_callbacks = /* @__PURE__ */ new Set();
   /**
    * The number of async effects that are currently in flight
    */
   #pending = 0;
+  /**
+   * The number of async effects that are currently in flight, _not_ inside a pending boundary
+   */
+  #blocking_pending = 0;
   /**
    * A deferred that resolves when the batch is committed, used with `settled()`
    * TODO replace with Promise.withResolvers once supported widely enough
    * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
    */
   #deferred = null;
-  /**
-   * Async effects inside a newly-created `<svelte:boundary>`
-   * — these do not prevent the batch from committing
-   * @type {Effect[]}
-   */
-  #boundary_async_effects = [];
-  /**
-   * Template effects and `$effect.pre` effects, which run when
-   * a batch is committed
-   * @type {Effect[]}
-   */
-  #render_effects = [];
-  /**
-   * The same as `#render_effects`, but for `$effect` (which runs after)
-   * @type {Effect[]}
-   */
-  #effects = [];
-  /**
-   * Block effects, which may need to re-run on subsequent flushes
-   * in order to update internal sources (e.g. each block items)
-   * @type {Effect[]}
-   */
-  #block_effects = [];
   /**
    * Deferred effects (which run after async work has completed) that are DIRTY
    * @type {Effect[]}
@@ -1354,6 +1329,7 @@ class Batch {
    * @type {Set<Effect>}
    */
   skipped_effects = /* @__PURE__ */ new Set();
+  is_fork = false;
   /**
    *
    * @param {Effect[]} root_effects
@@ -1361,39 +1337,38 @@ class Batch {
   process(root_effects) {
     queued_root_effects = [];
     this.apply();
+    var target = {
+      parent: null,
+      effect: null,
+      effects: [],
+      render_effects: [],
+      block_effects: []
+    };
     for (const root2 of root_effects) {
-      this.#traverse_effect_tree(root2);
+      this.#traverse_effect_tree(root2, target);
     }
-    if (this.#pending === 0) {
-      var previous_batch_sources = batch_values;
-      this.#commit();
-      var render_effects = this.#render_effects;
-      var effects = this.#effects;
-      this.#render_effects = [];
-      this.#effects = [];
-      this.#block_effects = [];
+    if (!this.is_fork) {
+      this.#resolve();
+    }
+    if (this.#blocking_pending > 0 || this.is_fork) {
+      this.#defer_effects(target.effects);
+      this.#defer_effects(target.render_effects);
+      this.#defer_effects(target.block_effects);
+    } else {
       current_batch = null;
-      batch_values = previous_batch_sources;
-      flush_queued_effects(render_effects);
-      flush_queued_effects(effects);
+      flush_queued_effects(target.render_effects);
+      flush_queued_effects(target.effects);
       this.#deferred?.resolve();
-    } else {
-      this.#defer_effects(this.#render_effects);
-      this.#defer_effects(this.#effects);
-      this.#defer_effects(this.#block_effects);
     }
     batch_values = null;
-    for (const effect of this.#boundary_async_effects) {
-      update_effect(effect);
-    }
-    this.#boundary_async_effects = [];
   }
   /**
    * Traverse the effect tree, executing effects or stashing
    * them for later execution as appropriate
    * @param {Effect} root
+   * @param {EffectTarget} target
    */
-  #traverse_effect_tree(root2) {
+  #traverse_effect_tree(root2, target) {
     root2.f ^= CLEAN;
     var effect = root2.first;
     while (effect !== null) {
@@ -1401,18 +1376,23 @@ class Batch {
       var is_branch = (flags2 & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
       var is_skippable_branch = is_branch && (flags2 & CLEAN) !== 0;
       var skip = is_skippable_branch || (flags2 & INERT) !== 0 || this.skipped_effects.has(effect);
+      if ((effect.f & BOUNDARY_EFFECT) !== 0 && effect.b?.is_pending()) {
+        target = {
+          parent: target,
+          effect,
+          effects: [],
+          render_effects: [],
+          block_effects: []
+        };
+      }
       if (!skip && effect.fn !== null) {
         if (is_branch) {
           effect.f ^= CLEAN;
         } else if ((flags2 & EFFECT) !== 0) {
-          this.#effects.push(effect);
-        } else if ((flags2 & CLEAN) === 0) {
-          if ((flags2 & ASYNC) !== 0 && effect.b?.is_pending()) {
-            this.#boundary_async_effects.push(effect);
-          } else if (is_dirty(effect)) {
-            if ((effect.f & BLOCK_EFFECT) !== 0) this.#block_effects.push(effect);
-            update_effect(effect);
-          }
+          target.effects.push(effect);
+        } else if (is_dirty(effect)) {
+          if ((effect.f & BLOCK_EFFECT) !== 0) target.block_effects.push(effect);
+          update_effect(effect);
         }
         var child = effect.first;
         if (child !== null) {
@@ -1423,6 +1403,13 @@ class Batch {
       var parent = effect.parent;
       effect = effect.next;
       while (effect === null && parent !== null) {
+        if (parent === target.effect) {
+          this.#defer_effects(target.effects);
+          this.#defer_effects(target.render_effects);
+          this.#defer_effects(target.block_effects);
+          target = /** @type {EffectTarget} */
+          target.parent;
+        }
         effect = parent.next;
         parent = parent.parent;
       }
@@ -1437,7 +1424,6 @@ class Batch {
       target.push(e);
       set_signal_status(e, CLEAN);
     }
-    effects.length = 0;
   }
   /**
    * Associate a change to a given source with the current
@@ -1446,8 +1432,8 @@ class Batch {
    * @param {any} value
    */
   capture(source2, value) {
-    if (!this.#previous.has(source2)) {
-      this.#previous.set(source2, value);
+    if (!this.previous.has(source2)) {
+      this.previous.set(source2, value);
     }
     this.current.set(source2, source2.v);
     batch_values?.set(source2, source2.v);
@@ -1460,35 +1446,42 @@ class Batch {
     batch_values = null;
   }
   flush() {
+    this.activate();
     if (queued_root_effects.length > 0) {
-      this.activate();
       flush_effects();
       if (current_batch !== null && current_batch !== this) {
         return;
       }
     } else if (this.#pending === 0) {
-      this.#commit();
+      this.process([]);
     }
     this.deactivate();
-    for (const update of effect_pending_updates) {
-      effect_pending_updates.delete(update);
-      update();
-      if (current_batch !== null) {
-        break;
-      }
+  }
+  discard() {
+    for (const fn of this.#discard_callbacks) fn(this);
+    this.#discard_callbacks.clear();
+  }
+  #resolve() {
+    if (this.#blocking_pending === 0) {
+      for (const fn of this.#commit_callbacks) fn();
+      this.#commit_callbacks.clear();
+    }
+    if (this.#pending === 0) {
+      this.#commit();
     }
   }
-  /**
-   * Append and remove branches to/from the DOM
-   */
   #commit() {
-    for (const fn of this.#callbacks) {
-      fn();
-    }
-    this.#callbacks.clear();
     if (batches.size > 1) {
-      this.#previous.clear();
-      let is_earlier = true;
+      this.previous.clear();
+      var previous_batch_values = batch_values;
+      var is_earlier = true;
+      var dummy_target = {
+        parent: null,
+        effect: null,
+        effects: [],
+        render_effects: [],
+        block_effects: []
+      };
       for (const batch of batches) {
         if (batch === this) {
           is_earlier = false;
@@ -1510,14 +1503,16 @@ class Batch {
         }
         const others = [...batch.current.keys()].filter((s) => !this.current.has(s));
         if (others.length > 0) {
+          const marked = /* @__PURE__ */ new Set();
+          const checked = /* @__PURE__ */ new Map();
           for (const source2 of sources) {
-            mark_effects(source2, others);
+            mark_effects(source2, others, marked, checked);
           }
           if (queued_root_effects.length > 0) {
             current_batch = batch;
             batch.apply();
             for (const root2 of queued_root_effects) {
-              batch.#traverse_effect_tree(root2);
+              batch.#traverse_effect_tree(root2, dummy_target);
             }
             queued_root_effects = [];
             batch.deactivate();
@@ -1525,14 +1520,29 @@ class Batch {
         }
       }
       current_batch = null;
+      batch_values = previous_batch_values;
     }
+    this.committed = true;
     batches.delete(this);
   }
-  increment() {
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  increment(blocking) {
     this.#pending += 1;
+    if (blocking) this.#blocking_pending += 1;
   }
-  decrement() {
+  /**
+   *
+   * @param {boolean} blocking
+   */
+  decrement(blocking) {
     this.#pending -= 1;
+    if (blocking) this.#blocking_pending -= 1;
+    this.revive();
+  }
+  revive() {
     for (const e of this.#dirty_effects) {
       set_signal_status(e, DIRTY);
       schedule_effect(e);
@@ -1541,11 +1551,17 @@ class Batch {
       set_signal_status(e, MAYBE_DIRTY);
       schedule_effect(e);
     }
+    this.#dirty_effects = [];
+    this.#maybe_dirty_effects = [];
     this.flush();
   }
   /** @param {() => void} fn */
-  add_callback(fn) {
-    this.#callbacks.add(fn);
+  oncommit(fn) {
+    this.#commit_callbacks.add(fn);
+  }
+  /** @param {(batch: Batch) => void} fn */
+  ondiscard(fn) {
+    this.#discard_callbacks.add(fn);
   }
   settled() {
     return (this.#deferred ??= deferred()).promise;
@@ -1634,7 +1650,7 @@ function flush_queued_effects(effects) {
   while (i < length) {
     var effect = effects[i++];
     if ((effect.f & (DESTROYED | INERT)) === 0 && is_dirty(effect)) {
-      eager_block_effects = [];
+      eager_block_effects = /* @__PURE__ */ new Set();
       update_effect(effect);
       if (effect.deps === null && effect.first === null && effect.nodes_start === null) {
         if (effect.teardown === null && effect.ac === null) {
@@ -1643,18 +1659,34 @@ function flush_queued_effects(effects) {
           effect.fn = null;
         }
       }
-      if (eager_block_effects?.length > 0) {
+      if (eager_block_effects?.size > 0) {
         old_values.clear();
         for (const e of eager_block_effects) {
-          update_effect(e);
+          if ((e.f & (DESTROYED | INERT)) !== 0) continue;
+          const ordered_effects = [e];
+          let ancestor = e.parent;
+          while (ancestor !== null) {
+            if (eager_block_effects.has(ancestor)) {
+              eager_block_effects.delete(ancestor);
+              ordered_effects.push(ancestor);
+            }
+            ancestor = ancestor.parent;
+          }
+          for (let j = ordered_effects.length - 1; j >= 0; j--) {
+            const e2 = ordered_effects[j];
+            if ((e2.f & (DESTROYED | INERT)) !== 0) continue;
+            update_effect(e2);
+          }
         }
-        eager_block_effects = [];
+        eager_block_effects.clear();
       }
     }
   }
   eager_block_effects = null;
 }
-function mark_effects(value, sources) {
+function mark_effects(value, sources, marked, checked) {
+  if (marked.has(value)) return;
+  marked.add(value);
   if (value.reactions !== null) {
     for (const reaction of value.reactions) {
       const flags2 = reaction.f;
@@ -1662,9 +1694,12 @@ function mark_effects(value, sources) {
         mark_effects(
           /** @type {Derived} */
           reaction,
-          sources
+          sources,
+          marked,
+          checked
         );
-      } else if ((flags2 & (ASYNC | BLOCK_EFFECT)) !== 0 && depends_on(reaction, sources)) {
+      } else if ((flags2 & (ASYNC | BLOCK_EFFECT)) !== 0 && (flags2 & DIRTY) === 0 && // we may have scheduled this one already
+      depends_on(reaction, sources, checked)) {
         set_signal_status(reaction, DIRTY);
         schedule_effect(
           /** @type {Effect} */
@@ -1674,7 +1709,9 @@ function mark_effects(value, sources) {
     }
   }
 }
-function depends_on(reaction, sources) {
+function depends_on(reaction, sources, checked) {
+  const depends = checked.get(reaction);
+  if (depends !== void 0) return depends;
   if (reaction.deps !== null) {
     for (const dep of reaction.deps) {
       if (sources.includes(dep)) {
@@ -1683,12 +1720,19 @@ function depends_on(reaction, sources) {
       if ((dep.f & DERIVED) !== 0 && depends_on(
         /** @type {Derived} */
         dep,
-        sources
+        sources,
+        checked
       )) {
+        checked.set(
+          /** @type {Derived} */
+          dep,
+          true
+        );
         return true;
       }
     }
   }
+  checked.set(reaction, false);
   return false;
 }
 function schedule_effect(signal) {
@@ -1758,6 +1802,8 @@ class Boundary {
   #failed_effect = null;
   /** @type {DocumentFragment | null} */
   #offscreen_fragment = null;
+  /** @type {TemplateNode | null} */
+  #pending_anchor = null;
   #local_pending_count = 0;
   #pending_count = 0;
   #is_creating_fallback = false;
@@ -1769,11 +1815,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 () => {
@@ -1808,8 +1849,9 @@ class Boundary {
           this.#hydrate_resolved_content();
         }
       } 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);
         }
@@ -1819,6 +1861,9 @@ class Boundary {
           this.#pending = false;
         }
       }
+      return () => {
+        this.#pending_anchor?.remove();
+      };
     }, flags);
     if (hydrating) {
       this.#anchor = hydrate_node;
@@ -1839,9 +1884,10 @@ class Boundary {
     }
     this.#pending_effect = branch(() => pending(this.#anchor));
     Batch.enqueue(() => {
+      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();
@@ -1857,6 +1903,15 @@ class Boundary {
       }
     });
   }
+  #get_anchor() {
+    var anchor = this.#anchor;
+    if (this.#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
    * @returns {boolean}
@@ -1895,6 +1950,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) {
@@ -1925,9 +1984,6 @@ class Boundary {
         this.#anchor.before(this.#offscreen_fragment);
         this.#offscreen_fragment = null;
       }
-      queue_micro_task(() => {
-        Batch.ensure().flush();
-      });
     }
   }
   /**
@@ -1939,7 +1995,9 @@ 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) {
+      internal_set(this.#effect_pending, this.#local_pending_count);
+    }
   }
   get_effect_pending() {
     this.#effect_pending_subscriber();
@@ -2018,6 +2076,7 @@ class Boundary {
     if (failed) {
       queue_micro_task(() => {
         this.#failed_effect = this.#run(() => {
+          Batch.ensure();
           this.#is_creating_fallback = true;
           try {
             return branch(() => {
@@ -2042,18 +2101,6 @@ class Boundary {
     }
   }
 }
-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} */
-      /* @__PURE__ */ get_next_sibling(node)
-    );
-    fragment.append(node);
-    node = next2;
-  }
-}
 function destroy_derived_effects(derived) {
   var effects = derived.effects;
   if (effects !== null) {
@@ -2085,6 +2132,7 @@ function execute_derived(derived) {
   set_active_effect(get_derived_parent_effect(derived));
   {
     try {
+      derived.f &= ~WAS_MARKED;
       destroy_derived_effects(derived);
       value = update_reaction(derived);
     } finally {
@@ -2109,7 +2157,9 @@ function update_derived(derived) {
     set_signal_status(derived, status);
   }
 }
+let eager_effects = /* @__PURE__ */ new Set();
 const old_values = /* @__PURE__ */ new Map();
+let eager_effects_deferred = false;
 function source(v, stack) {
   var signal = {
     f: 0,
@@ -2139,7 +2189,7 @@ function mutable_source(initial_value, immutable = false, trackable = true) {
 function set(source2, value, should_proxy = false) {
   if (active_reaction !== null && // since we are untracking the function inside `$inspect.with` we need to add this check
   // to ensure we error if state is set inside an inspect effect
-  (!untracking || (active_reaction.f & INSPECT_EFFECT) !== 0) && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | INSPECT_EFFECT)) !== 0 && !current_sources?.includes(source2)) {
+  (!untracking || (active_reaction.f & EAGER_EFFECT) !== 0) && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT | ASYNC | EAGER_EFFECT)) !== 0 && !current_sources?.includes(source2)) {
     state_unsafe_mutation();
   }
   let new_value = should_proxy ? proxy(value) : value;
@@ -2174,9 +2224,25 @@ function internal_set(source2, value) {
         untracked_writes.push(source2);
       }
     }
+    if (!batch.is_fork && eager_effects.size > 0 && !eager_effects_deferred) {
+      flush_eager_effects();
+    }
   }
   return value;
 }
+function flush_eager_effects() {
+  eager_effects_deferred = false;
+  const inspects = Array.from(eager_effects);
+  for (const effect of inspects) {
+    if ((effect.f & CLEAN) !== 0) {
+      set_signal_status(effect, MAYBE_DIRTY);
+    }
+    if (is_dirty(effect)) {
+      update_effect(effect);
+    }
+  }
+  eager_effects.clear();
+}
 function increment(source2) {
   set(source2, source2.v + 1);
 }
@@ -2192,15 +2258,18 @@ function mark_reactions(signal, status) {
       set_signal_status(reaction, status);
     }
     if ((flags2 & DERIVED) !== 0) {
-      mark_reactions(
-        /** @type {Derived} */
-        reaction,
-        MAYBE_DIRTY
-      );
+      if ((flags2 & WAS_MARKED) === 0) {
+        reaction.f |= WAS_MARKED;
+        mark_reactions(
+          /** @type {Derived} */
+          reaction,
+          MAYBE_DIRTY
+        );
+      }
     } else if (not_dirty) {
       if ((flags2 & BLOCK_EFFECT) !== 0) {
         if (eager_block_effects !== null) {
-          eager_block_effects.push(
+          eager_block_effects.add(
             /** @type {Effect} */
             reaction
           );
@@ -2502,6 +2571,9 @@ function create_effect(type, fn, sync, push2 = true) {
     if (sync && e.deps === null && e.teardown === null && e.nodes_start === null && e.first === e.last && // either `null`, or a singular child
     (e.f & EFFECT_PRESERVED) === 0) {
       e = e.first;
+      if ((type & BLOCK_EFFECT) !== 0 && (type & EFFECT_TRANSPARENT) !== 0 && e !== null) {
+        e.f |= EFFECT_TRANSPARENT;
+      }
     }
     if (e !== null) {
       e.parent = parent;
@@ -2643,11 +2715,11 @@ function unlink_effect(effect) {
     if (parent.last === effect) parent.last = prev;
   }
 }
-function pause_effect(effect, callback) {
+function pause_effect(effect, callback, destroy = true) {
   var transitions = [];
   pause_children(effect, transitions, true);
   run_out_transitions(transitions, () => {
-    destroy_effect(effect);
+    if (destroy) destroy_effect(effect);
     if (callback) callback();
   });
 }
@@ -2675,11 +2747,26 @@ function pause_children(effect, transitions, local) {
   var child = effect.first;
   while (child !== null) {
     var sibling = child.next;
-    var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || (child.f & BRANCH_EFFECT) !== 0;
+    var transparent = (child.f & EFFECT_TRANSPARENT) !== 0 || // If this is a branch effect without a block effect parent,
+    // it means the parent block effect was pruned. In that case,
+    // transparency information was transferred to the branch effect.
+    (child.f & BRANCH_EFFECT) !== 0 && (effect.f & BLOCK_EFFECT) !== 0;
     pause_children(child, transitions, transparent ? local : false);
     child = sibling;
   }
 }
+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} */
+      /* @__PURE__ */ get_next_sibling(node)
+    );
+    fragment.append(node);
+    node = next2;
+  }
+}
 let is_updating_effect = false;
 function set_is_updating_effect(value) {
   is_updating_effect = value;
@@ -2731,6 +2818,9 @@ function is_dirty(reaction) {
   if ((flags2 & MAYBE_DIRTY) !== 0) {
     var dependencies = reaction.deps;
     var is_unowned = (flags2 & UNOWNED) !== 0;
+    if (flags2 & DERIVED) {
+      reaction.f &= ~WAS_MARKED;
+    }
     if (dependencies !== null) {
       var i;
       var dependency;
@@ -3129,12 +3219,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) {
@@ -3632,7 +3717,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: "1qcsm56"
+  version_hash: "142war7"
 };
 async function get_hooks() {
   let handle;
@@ -3672,6 +3757,291 @@ function create_remote_cache_key(id, payload) {
   return id + "/" + payload;
 }
 
+var cookie = {};
+
+/*!
+ * cookie
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredCookie;
+
+function requireCookie () {
+	if (hasRequiredCookie) return cookie;
+	hasRequiredCookie = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	cookie.parse = parse;
+	cookie.serialize = serialize;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var __toString = Object.prototype.toString;
+
+	/**
+	 * RegExp to match field-content in RFC 7230 sec 3.2
+	 *
+	 * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+	 * field-vchar   = VCHAR / obs-text
+	 * obs-text      = %x80-FF
+	 */
+
+	var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+
+	/**
+	 * Parse a cookie header.
+	 *
+	 * Parse the given cookie header string into an object
+	 * The object has the various cookies as keys(names) => values
+	 *
+	 * @param {string} str
+	 * @param {object} [options]
+	 * @return {object}
+	 * @public
+	 */
+
+	function parse(str, options) {
+	  if (typeof str !== 'string') {
+	    throw new TypeError('argument str must be a string');
+	  }
+
+	  var obj = {};
+	  var opt = options || {};
+	  var dec = opt.decode || decode;
+
+	  var index = 0;
+	  while (index < str.length) {
+	    var eqIdx = str.indexOf('=', index);
+
+	    // no more cookie pairs
+	    if (eqIdx === -1) {
+	      break
+	    }
+
+	    var endIdx = str.indexOf(';', index);
+
+	    if (endIdx === -1) {
+	      endIdx = str.length;
+	    } else if (endIdx < eqIdx) {
+	      // backtrack on prior semicolon
+	      index = str.lastIndexOf(';', eqIdx - 1) + 1;
+	      continue
+	    }
+
+	    var key = str.slice(index, eqIdx).trim();
+
+	    // only assign once
+	    if (undefined === obj[key]) {
+	      var val = str.slice(eqIdx + 1, endIdx).trim();
+
+	      // quoted values
+	      if (val.charCodeAt(0) === 0x22) {
+	        val = val.slice(1, -1);
+	      }
+
+	      obj[key] = tryDecode(val, dec);
+	    }
+
+	    index = endIdx + 1;
+	  }
+
+	  return obj;
+	}
+
+	/**
+	 * Serialize data into a cookie header.
+	 *
+	 * Serialize the a name value pair into a cookie string suitable for
+	 * http headers. An optional options object specified cookie parameters.
+	 *
+	 * serialize('foo', 'bar', { httpOnly: true })
+	 *   => "foo=bar; httpOnly"
+	 *
+	 * @param {string} name
+	 * @param {string} val
+	 * @param {object} [options]
+	 * @return {string}
+	 * @public
+	 */
+
+	function serialize(name, val, options) {
+	  var opt = options || {};
+	  var enc = opt.encode || encode;
+
+	  if (typeof enc !== 'function') {
+	    throw new TypeError('option encode is invalid');
+	  }
+
+	  if (!fieldContentRegExp.test(name)) {
+	    throw new TypeError('argument name is invalid');
+	  }
+
+	  var value = enc(val);
+
+	  if (value && !fieldContentRegExp.test(value)) {
+	    throw new TypeError('argument val is invalid');
+	  }
+
+	  var str = name + '=' + value;
+
+	  if (null != opt.maxAge) {
+	    var maxAge = opt.maxAge - 0;
+
+	    if (isNaN(maxAge) || !isFinite(maxAge)) {
+	      throw new TypeError('option maxAge is invalid')
+	    }
+
+	    str += '; Max-Age=' + Math.floor(maxAge);
+	  }
+
+	  if (opt.domain) {
+	    if (!fieldContentRegExp.test(opt.domain)) {
+	      throw new TypeError('option domain is invalid');
+	    }
+
+	    str += '; Domain=' + opt.domain;
+	  }
+
+	  if (opt.path) {
+	    if (!fieldContentRegExp.test(opt.path)) {
+	      throw new TypeError('option path is invalid');
+	    }
+
+	    str += '; Path=' + opt.path;
+	  }
+
+	  if (opt.expires) {
+	    var expires = opt.expires;
+
+	    if (!isDate(expires) || isNaN(expires.valueOf())) {
+	      throw new TypeError('option expires is invalid');
+	    }
+
+	    str += '; Expires=' + expires.toUTCString();
+	  }
+
+	  if (opt.httpOnly) {
+	    str += '; HttpOnly';
+	  }
+
+	  if (opt.secure) {
+	    str += '; Secure';
+	  }
+
+	  if (opt.partitioned) {
+	    str += '; Partitioned';
+	  }
+
+	  if (opt.priority) {
+	    var priority = typeof opt.priority === 'string'
+	      ? opt.priority.toLowerCase()
+	      : opt.priority;
+
+	    switch (priority) {
+	      case 'low':
+	        str += '; Priority=Low';
+	        break
+	      case 'medium':
+	        str += '; Priority=Medium';
+	        break
+	      case 'high':
+	        str += '; Priority=High';
+	        break
+	      default:
+	        throw new TypeError('option priority is invalid')
+	    }
+	  }
+
+	  if (opt.sameSite) {
+	    var sameSite = typeof opt.sameSite === 'string'
+	      ? opt.sameSite.toLowerCase() : opt.sameSite;
+
+	    switch (sameSite) {
+	      case true:
+	        str += '; SameSite=Strict';
+	        break;
+	      case 'lax':
+	        str += '; SameSite=Lax';
+	        break;
+	      case 'strict':
+	        str += '; SameSite=Strict';
+	        break;
+	      case 'none':
+	        str += '; SameSite=None';
+	        break;
+	      default:
+	        throw new TypeError('option sameSite is invalid');
+	    }
+	  }
+
+	  return str;
+	}
+
+	/**
+	 * URL-decode string value. Optimized to skip native call when no %.
+	 *
+	 * @param {string} str
+	 * @returns {string}
+	 */
+
+	function decode (str) {
+	  return str.indexOf('%') !== -1
+	    ? decodeURIComponent(str)
+	    : str
+	}
+
+	/**
+	 * URL-encode value.
+	 *
+	 * @param {string} val
+	 * @returns {string}
+	 */
+
+	function encode (val) {
+	  return encodeURIComponent(val)
+	}
+
+	/**
+	 * Determine if value is a Date.
+	 *
+	 * @param {*} val
+	 * @private
+	 */
+
+	function isDate (val) {
+	  return __toString.call(val) === '[object Date]' ||
+	    val instanceof Date
+	}
+
+	/**
+	 * Try decoding a string using a decoding function.
+	 *
+	 * @param {string} str
+	 * @param {function} decode
+	 * @private
+	 */
+
+	function tryDecode(str, decode) {
+	  try {
+	    return decode(str);
+	  } catch (e) {
+	    return str;
+	  }
+	}
+	return cookie;
+}
+
+var cookieExports = requireCookie();
+
 var setCookie = {exports: {}};
 
 var hasRequiredSetCookie;
@@ -3686,6 +4056,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();
 	}
@@ -3702,30 +4080,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") {
@@ -3734,7 +4117,7 @@ function requireSetCookie () {
 	      cookie.sameSite = value;
 	    } else if (key === "partitioned") {
 	      cookie.partitioned = true;
-	    } else {
+	    } else if (key) {
 	      cookie[key] = value;
 	    }
 	  });
@@ -3767,7 +4150,7 @@ function requireSetCookie () {
 	    if (!options.map) {
 	      return [];
 	    } else {
-	      return {};
+	      return createNullObj();
 	    }
 	  }
 
@@ -3777,7 +4160,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
@@ -3801,14 +4184,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);
 	  }
@@ -4517,46 +4905,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);
       });
     }
   };
@@ -5965,7 +6336,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();
       },
@@ -6819,7 +7190,7 @@ function generate_cookie_key(domain, path, name) {
 }
 function get_cookies(request, url) {
   const header = request.headers.get("cookie") ?? "";
-  const initial_cookies = parse$1(header, { decode: (value) => value });
+  const initial_cookies = cookieExports.parse(header, { decode: (value) => value });
   let normalized_url;
   const new_cookies = /* @__PURE__ */ new Map();
   const defaults = {
@@ -6843,7 +7214,7 @@ function get_cookies(request, url) {
       if (best_match) {
         return best_match.options.maxAge === 0 ? void 0 : best_match.value;
       }
-      const req_cookies = parse$1(header, { decode: opts?.decode });
+      const req_cookies = cookieExports.parse(header, { decode: opts?.decode });
       const cookie = req_cookies[name];
       return cookie;
     },
@@ -6851,7 +7222,7 @@ function get_cookies(request, url) {
      * @param {import('cookie').CookieParseOptions} [opts]
      */
     getAll(opts) {
-      const cookies2 = parse$1(header, { decode: opts?.decode });
+      const cookies2 = cookieExports.parse(header, { decode: opts?.decode });
       const lookup = /* @__PURE__ */ new Map();
       for (const c of new_cookies.values()) {
         if (domain_matches(url.hostname, c.options.domain) && path_matches(url.pathname, c.options.path)) {
@@ -6905,7 +7276,7 @@ function get_cookies(request, url) {
         }
         path = resolve(normalized_url, path);
       }
-      return serialize(name, value, { ...defaults, ...options2, path });
+      return cookieExports.serialize(name, value, { ...defaults, ...options2, path });
     }
   };
   function get_cookie_header(destination, header2) {
@@ -6920,7 +7291,7 @@ function get_cookies(request, url) {
       combined_cookies[cookie.name] = encoder(cookie.value);
     }
     if (header2) {
-      const parsed = parse$1(header2, { decode: (value) => value });
+      const parsed = cookieExports.parse(header2, { decode: (value) => value });
       for (const name in parsed) {
         combined_cookies[name] = parsed[name];
       }
@@ -6962,10 +7333,10 @@ function path_matches(path, constraint) {
 function add_cookies_to_headers(headers2, cookies) {
   for (const new_cookie of cookies) {
     const { name, value, options: options2 } = new_cookie;
-    headers2.append("set-cookie", serialize(name, value, options2));
+    headers2.append("set-cookie", cookieExports.serialize(name, value, options2));
     if (options2.path.endsWith(".html")) {
       const path = add_data_suffix(options2.path);
-      headers2.append("set-cookie", serialize(name, value, { ...options2, path }));
+      headers2.append("set-cookie", cookieExports.serialize(name, value, { ...options2, path }));
     }
   }
 }