@axium/server 0.15.2 → 0.15.3

package/build/server/index.js

@@ -1,4 +1,6 @@
-import { r as render, L as LEGACY_PROPS, d as define_property, U as UNOWNED, C as COMMENT_NODE, H as HYDRATION_START, a as HYDRATION_ERROR, b as HYDRATION_END, s as safe_equals, S as STATE_SYMBOL, o as object_prototype, c as array_prototype, e as UNINITIALIZED, g as get_descriptor, D as DERIVED, f as DIRTY, h as CLEAN, M as MAYBE_DIRTY, i as DISCONNECTED, j as is_extensible, k as array_from, l as equals, m as get_prototype_of, n as is_array, p as is_passive_event, q as run_all, I as INERT, E as EFFECT, t as DESTROYED, u as USER_EFFECT, v as EFFECT_IS_UPDATING, B as BRANCH_EFFECT, R as ROOT_EFFECT, w as STALE_REACTION, x as EFFECT_RAN, y as EFFECT_PRESERVED, z as BOUNDARY_EFFECT, A as HEAD_EFFECT, F as BLOCK_EFFECT, G as DEV, J as EFFECT_TRANSPARENT, K as index_of, N as INSPECT_EFFECT, O as RENDER_EFFECT, P as push$1, Q as setContext, T as pop$1, V as decode_pathname, W as decode_params, X as normalize_path, Y as disable_search, Z as validate_layout_server_exports, _ as validate_layout_exports, $ as validate_page_server_exports, a0 as validate_page_exports, a1 as resolve, a2 as make_trackable, a3 as readable, a4 as writable } from './chunks/exports-Bdi6Ec6W.js';
+import { r as render, L as LEGACY_PROPS, d as define_property, 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 safe_equals, S as STATE_SYMBOL, o as object_prototype, c as array_prototype, e as UNINITIALIZED, g as get_descriptor, D as DERIVED, f as DIRTY, h as CLEAN, M as MAYBE_DIRTY, i as DISCONNECTED, j as is_extensible, k as array_from, I as INERT, l as EFFECT, A as ASYNC, B as BLOCK_EFFECT, m as DEV, n as deferred, p as equals, q as get_prototype_of, t as is_array, u as is_passive_event, v as BRANCH_EFFECT, R as ROOT_EFFECT, w as DESTROYED, x as USER_EFFECT, y as run_all, z as STALE_REACTION, F as REACTION_IS_UPDATING, G as EFFECT_RAN, J as EFFECT_PRESERVED, K as HEAD_EFFECT, N as BOUNDARY_EFFECT, O as EFFECT_TRANSPARENT, P as index_of, Q as INSPECT_EFFECT, T as push$1, V as setContext, W as pop$1, X as decode_pathname, Y as decode_params, Z as normalize_path, _ as disable_search, $ as validate_layout_server_exports, a0 as validate_layout_exports, a1 as validate_page_server_exports, a2 as validate_page_exports, a3 as resolve, a4 as make_trackable, a5 as readable, a6 as writable } from './chunks/exports-BObzsBSm.js';
+import { json, text } from '@sveltejs/kit';
+import { HttpError, Redirect, SvelteKitError, ActionFailure } from '@sveltejs/kit/internal';
 import { parse, serialize } from 'cookie';
 
 let base = "";
@@ -46,56 +48,664 @@ function state_unsafe_mutation() {
     throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
   }
 }
+function hydration_mismatch(location) {
+  {
+    console.warn(`https://svelte.dev/e/hydration_mismatch`);
+  }
+}
+let hydrating = false;
+function set_hydrating(value) {
+  hydrating = value;
+}
+let hydrate_node;
+function set_hydrate_node(node) {
+  if (node === null) {
+    hydration_mismatch();
+    throw HYDRATION_ERROR;
+  }
+  return hydrate_node = node;
+}
+function hydrate_next() {
+  return set_hydrate_node(
+    /** @type {TemplateNode} */
+    /* @__PURE__ */ get_next_sibling(hydrate_node)
+  );
+}
 let tracing_mode_flag = false;
 let component_context = null;
 function set_component_context(context) {
   component_context = context;
 }
-function push(props, runes = false, fn) {
-  var ctx = component_context = {
-    p: component_context,
-    c: null,
-    d: false,
-    e: null,
-    m: false,
-    s: props,
-    x: null,
-    l: null
-  };
-  teardown(() => {
-    ctx.d = true;
-  });
+function push(props, runes = false, fn) {
+  component_context = {
+    p: component_context,
+    c: null,
+    e: null,
+    s: props,
+    x: null,
+    l: null
+  };
+}
+function pop(component) {
+  var context = (
+    /** @type {ComponentContext} */
+    component_context
+  );
+  var effects = context.e;
+  if (effects !== null) {
+    context.e = null;
+    for (var fn of effects) {
+      create_user_effect(fn);
+    }
+  }
+  component_context = context.p;
+  return (
+    /** @type {T} */
+    {}
+  );
+}
+function is_runes() {
+  return true;
+}
+const adjustments = /* @__PURE__ */ new WeakMap();
+function handle_error(error) {
+  var effect = active_effect;
+  if (effect === null) {
+    active_reaction.f |= ERROR_VALUE;
+    return 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);
+  } else {
+    invoke_error_boundary(error, effect);
+  }
+}
+function invoke_error_boundary(error, effect) {
+  while (effect !== null) {
+    if ((effect.f & BOUNDARY_EFFECT) !== 0) {
+      try {
+        effect.b.error(error);
+        return;
+      } catch (e) {
+        error = e;
+      }
+    }
+    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
+    });
+  }
+}
+let micro_tasks = [];
+let idle_tasks = [];
+function run_micro_tasks() {
+  var tasks2 = micro_tasks;
+  micro_tasks = [];
+  run_all(tasks2);
+}
+function run_idle_tasks() {
+  var tasks2 = idle_tasks;
+  idle_tasks = [];
+  run_all(tasks2);
+}
+function flush_tasks() {
+  if (micro_tasks.length > 0) {
+    run_micro_tasks();
+  }
+  if (idle_tasks.length > 0) {
+    run_idle_tasks();
+  }
+}
+function destroy_derived_effects(derived) {
+  var effects = derived.effects;
+  if (effects !== null) {
+    derived.effects = null;
+    for (var i = 0; i < effects.length; i += 1) {
+      destroy_effect(
+        /** @type {Effect} */
+        effects[i]
+      );
+    }
+  }
+}
+function get_derived_parent_effect(derived) {
+  var parent = derived.parent;
+  while (parent !== null) {
+    if ((parent.f & DERIVED) === 0) {
+      return (
+        /** @type {Effect} */
+        parent
+      );
+    }
+    parent = parent.parent;
+  }
+  return null;
+}
+function execute_derived(derived) {
+  var value;
+  var prev_active_effect = active_effect;
+  set_active_effect(get_derived_parent_effect(derived));
+  {
+    try {
+      destroy_derived_effects(derived);
+      value = update_reaction(derived);
+    } finally {
+      set_active_effect(prev_active_effect);
+    }
+  }
+  return value;
+}
+function update_derived(derived) {
+  var value = execute_derived(derived);
+  if (!derived.equals(value)) {
+    derived.v = value;
+    derived.wv = increment_write_version();
+  }
+  if (is_destroying_effect) {
+    return;
+  }
+  if (batch_deriveds !== null) {
+    batch_deriveds.set(derived, derived.v);
+  } else {
+    var status = (skip_reaction || (derived.f & UNOWNED) !== 0) && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
+    set_signal_status(derived, status);
+  }
+}
+const batches = /* @__PURE__ */ new Set();
+let current_batch = null;
+let batch_deriveds = null;
+let effect_pending_updates = /* @__PURE__ */ new Set();
+let tasks = [];
+function dequeue() {
+  const task = (
+    /** @type {() => void} */
+    tasks.shift()
+  );
+  if (tasks.length > 0) {
+    queueMicrotask(dequeue);
+  }
+  task();
+}
+let queued_root_effects = [];
+let last_scheduled_effect = null;
+let is_flushing = 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();
+  /**
+   * 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`
+   * @type {Map<Source, any>}
+   */
+  #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();
+  /**
+   * The number of async effects that are currently in flight
+   */
+  #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;
+  /**
+   * True if an async effect inside this batch resolved and
+   * its parent branch was already deleted
+   */
+  #neutered = false;
+  /**
+   * Async effects (created inside `async_derived`) encountered during processing.
+   * These run after the rest of the batch has updated, since they should
+   * always have the latest values
+   * @type {Effect[]}
+   */
+  #async_effects = [];
+  /**
+   * The same as `#async_effects`, but for 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 = [];
+  /**
+   * A set of branches that still exist, but will be destroyed when this batch
+   * is committed — we skip over these during `process`
+   * @type {Set<Effect>}
+   */
+  skipped_effects = /* @__PURE__ */ new Set();
+  /**
+   *
+   * @param {Effect[]} 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) {
+        current_values.set(source2, { v: source2.v, wv: source2.wv });
+        source2.v = current;
+      }
+      for (const batch of batches) {
+        if (batch === this) continue;
+        for (const [source2, previous] of batch.#previous) {
+          if (!current_values.has(source2)) {
+            current_values.set(source2, { v: source2.v, wv: source2.wv });
+            source2.v = previous;
+          }
+        }
+      }
+    }
+    for (const root2 of root_effects) {
+      this.#traverse_effect_tree(root2);
+    }
+    if (this.#async_effects.length === 0 && this.#pending === 0) {
+      var render_effects = this.#render_effects;
+      var effects = this.#effects;
+      this.#render_effects = [];
+      this.#effects = [];
+      this.#block_effects = [];
+      this.#commit();
+      flush_queued_effects(render_effects);
+      flush_queued_effects(effects);
+      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);
+    }
+    if (current_values) {
+      for (const [source2, { v, wv }] of current_values) {
+        if (source2.wv <= wv) {
+          source2.v = v;
+        }
+      }
+      batch_deriveds = null;
+    }
+    for (const effect of this.#async_effects) {
+      update_effect(effect);
+    }
+    for (const effect of this.#boundary_async_effects) {
+      update_effect(effect);
+    }
+    this.#async_effects = [];
+    this.#boundary_async_effects = [];
+  }
+  /**
+   * Traverse the effect tree, executing effects or stashing
+   * them for later execution as appropriate
+   * @param {Effect} root
+   */
+  #traverse_effect_tree(root2) {
+    root2.f ^= CLEAN;
+    var effect = root2.first;
+    while (effect !== null) {
+      var flags = effect.f;
+      var is_branch = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
+      var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
+      var skip = is_skippable_branch || (flags & INERT) !== 0 || this.skipped_effects.has(effect);
+      if (!skip && effect.fn !== null) {
+        if (is_branch) {
+          effect.f ^= CLEAN;
+        } else if ((flags & EFFECT) !== 0) {
+          this.#effects.push(effect);
+        } else if (is_dirty(effect)) {
+          if ((flags & ASYNC) !== 0) {
+            var effects = effect.b?.pending ? this.#boundary_async_effects : this.#async_effects;
+            effects.push(effect);
+          } else {
+            if ((effect.f & BLOCK_EFFECT) !== 0) this.#block_effects.push(effect);
+            update_effect(effect);
+          }
+        }
+        var child = effect.first;
+        if (child !== null) {
+          effect = child;
+          continue;
+        }
+      }
+      var parent = effect.parent;
+      effect = effect.next;
+      while (effect === null && parent !== null) {
+        effect = parent.next;
+        parent = parent.parent;
+      }
+    }
+  }
+  /**
+   * Associate a change to a given source with the current
+   * batch, noting its previous and current values
+   * @param {Source} source
+   * @param {any} value
+   */
+  capture(source2, value) {
+    if (!this.#previous.has(source2)) {
+      this.#previous.set(source2, value);
+    }
+    this.#current.set(source2, source2.v);
+  }
+  activate() {
+    current_batch = this;
+  }
+  deactivate() {
+    current_batch = null;
+    for (const update of effect_pending_updates) {
+      effect_pending_updates.delete(update);
+      update();
+      if (current_batch !== null) {
+        break;
+      }
+    }
+  }
+  neuter() {
+    this.#neutered = true;
+  }
+  flush() {
+    if (queued_root_effects.length > 0) {
+      this.flush_effects();
+    } else {
+      this.#commit();
+    }
+    if (current_batch !== this) {
+      return;
+    }
+    if (this.#pending === 0) {
+      batches.delete(this);
+    }
+    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
+   */
+  #commit() {
+    if (!this.#neutered) {
+      for (const fn of this.#callbacks) {
+        fn();
+      }
+    }
+    this.#callbacks.clear();
+  }
+  increment() {
+    this.#pending += 1;
+  }
+  decrement() {
+    this.#pending -= 1;
+    if (this.#pending === 0) {
+      for (const e of this.#render_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);
+        schedule_effect(e);
+      }
+      this.#render_effects = [];
+      this.#effects = [];
+      this.flush();
+    } else {
+      this.deactivate();
+    }
+  }
+  /** @param {() => void} fn */
+  add_callback(fn) {
+    this.#callbacks.add(fn);
+  }
+  settled() {
+    return (this.#deferred ??= deferred()).promise;
+  }
+  static ensure(autoflush = true) {
+    if (current_batch === null) {
+      const batch = current_batch = new Batch();
+      batches.add(current_batch);
+      if (autoflush) {
+        Batch.enqueue(() => {
+          if (current_batch !== batch) {
+            return;
+          }
+          batch.flush();
+        });
+      }
+    }
+    return current_batch;
+  }
+  /** @param {() => void} task */
+  static enqueue(task) {
+    if (tasks.length === 0) {
+      queueMicrotask(dequeue);
+    }
+    tasks.unshift(task);
+  }
+}
+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();
+      }
+      last_scheduled_effect = null;
+      return (
+        /** @type {T} */
+        result
+      );
+    }
+    batch.flush_effects();
+  }
+}
+function infinite_loop_guard() {
+  try {
+    effect_update_depth_exceeded();
+  } catch (error) {
+    invoke_error_boundary(error, last_scheduled_effect);
+  }
+}
+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;
+          }
+        }
+        if (write_version > wv && (effect.f & USER_EFFECT) !== 0) {
+          break;
+        }
+      }
+    }
+  }
+  for (; i < length; i += 1) {
+    schedule_effect(effects[i]);
+  }
+}
+function schedule_effect(signal) {
+  var effect = last_scheduled_effect = signal;
+  while (effect.parent !== null) {
+    effect = effect.parent;
+    var flags = effect.f;
+    if (is_flushing && effect === active_effect && (flags & BLOCK_EFFECT) !== 0) {
+      return;
+    }
+    if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
+      if ((flags & CLEAN) === 0) return;
+      effect.f ^= CLEAN;
+    }
+  }
+  queued_root_effects.push(effect);
+}
+const old_values = /* @__PURE__ */ new Map();
+function source(v, stack) {
+  var signal = {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v,
+    reactions: null,
+    equals,
+    rv: 0,
+    wv: 0
+  };
+  return signal;
+}
+// @__NO_SIDE_EFFECTS__
+function state(v, stack) {
+  const s = source(v);
+  push_reaction_value(s);
+  return s;
+}
+// @__NO_SIDE_EFFECTS__
+function mutable_source(initial_value, immutable = false, trackable = true) {
+  const s = source(initial_value);
+  if (!immutable) {
+    s.equals = safe_equals;
+  }
+  return s;
+}
+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)) {
+    state_unsafe_mutation();
+  }
+  let new_value = should_proxy ? proxy(value) : value;
+  return internal_set(source2, new_value);
 }
-function pop(component) {
-  const context_stack_item = component_context;
-  if (context_stack_item !== null) {
-    const component_effects = context_stack_item.e;
-    if (component_effects !== null) {
-      var previous_effect = active_effect;
-      var previous_reaction = active_reaction;
-      context_stack_item.e = null;
-      try {
-        for (var i = 0; i < component_effects.length; i++) {
-          var component_effect = component_effects[i];
-          set_active_effect(component_effect.effect);
-          set_active_reaction(component_effect.reaction);
-          create_user_effect(component_effect.fn);
-        }
-      } finally {
-        set_active_effect(previous_effect);
-        set_active_reaction(previous_reaction);
+function internal_set(source2, value) {
+  if (!source2.equals(value)) {
+    var old_value = source2.v;
+    if (is_destroying_effect) {
+      old_values.set(source2, value);
+    } else {
+      old_values.set(source2, old_value);
+    }
+    source2.v = value;
+    const batch = Batch.ensure();
+    batch.capture(source2, old_value);
+    if ((source2.f & DERIVED) !== 0) {
+      if ((source2.f & DIRTY) !== 0) {
+        execute_derived(
+          /** @type {Derived} */
+          source2
+        );
+      }
+      set_signal_status(source2, (source2.f & UNOWNED) === 0 ? CLEAN : MAYBE_DIRTY);
+    }
+    source2.wv = increment_write_version();
+    mark_reactions(source2, DIRTY);
+    if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
+      if (untracked_writes === null) {
+        set_untracked_writes([source2]);
+      } else {
+        untracked_writes.push(source2);
       }
     }
-    component_context = context_stack_item.p;
-    context_stack_item.m = true;
   }
-  return (
-    /** @type {T} */
-    {}
-  );
+  return value;
 }
-function is_runes() {
-  return true;
+function increment(source2) {
+  set(source2, source2.v + 1);
+}
+function mark_reactions(signal, status) {
+  var reactions = signal.reactions;
+  if (reactions === null) return;
+  var length = reactions.length;
+  for (var i = 0; i < length; i++) {
+    var reaction = reactions[i];
+    var flags = reaction.f;
+    if ((flags & DIRTY) === 0) {
+      set_signal_status(reaction, status);
+    }
+    if ((flags & DERIVED) !== 0) {
+      mark_reactions(
+        /** @type {Derived} */
+        reaction,
+        MAYBE_DIRTY
+      );
+    } else if ((flags & DIRTY) === 0) {
+      schedule_effect(
+        /** @type {Effect} */
+        reaction
+      );
+    }
+  }
 }
 function proxy(value) {
   if (typeof value !== "object" || value === null || STATE_SYMBOL in value) {
@@ -108,12 +718,18 @@ function proxy(value) {
   var sources = /* @__PURE__ */ new Map();
   var is_proxied_array = is_array(value);
   var version = /* @__PURE__ */ state(0);
-  var reaction = active_reaction;
+  var parent_version = update_version;
   var with_parent = (fn) => {
-    var previous_reaction = active_reaction;
-    set_active_reaction(reaction);
+    if (update_version === parent_version) {
+      return fn();
+    }
+    var reaction = active_reaction;
+    var version2 = update_version;
+    set_active_reaction(null);
+    set_update_version(parent_version);
     var result = fn();
-    set_active_reaction(previous_reaction);
+    set_active_reaction(reaction);
+    set_update_version(version2);
     return result;
   };
   if (is_proxied_array) {
@@ -148,21 +764,11 @@ function proxy(value) {
           if (prop in target) {
             const s2 = with_parent(() => /* @__PURE__ */ state(UNINITIALIZED));
             sources.set(prop, s2);
-            update_version(version);
+            increment(version);
           }
         } else {
-          if (is_proxied_array && typeof prop === "string") {
-            var ls = (
-              /** @type {Source<number>} */
-              sources.get("length")
-            );
-            var n = Number(prop);
-            if (Number.isInteger(n) && n < ls.v) {
-              set(ls, n);
-            }
-          }
           set(s, UNINITIALIZED);
-          update_version(version);
+          increment(version);
         }
         return true;
       },
@@ -268,193 +874,27 @@ function proxy(value) {
               set(ls, n + 1);
             }
           }
-          update_version(version);
+          increment(version);
         }
         return true;
       },
       ownKeys(target) {
-        get(version);
-        var own_keys = Reflect.ownKeys(target).filter((key2) => {
-          var source3 = sources.get(key2);
-          return source3 === void 0 || source3.v !== UNINITIALIZED;
-        });
-        for (var [key, source2] of sources) {
-          if (source2.v !== UNINITIALIZED && !(key in target)) {
-            own_keys.push(key);
-          }
-        }
-        return own_keys;
-      },
-      setPrototypeOf() {
-        state_prototype_fixed();
-      }
-    }
-  );
-}
-function update_version(signal, d = 1) {
-  set(signal, signal.v + d);
-}
-function destroy_derived_effects(derived) {
-  var effects = derived.effects;
-  if (effects !== null) {
-    derived.effects = null;
-    for (var i = 0; i < effects.length; i += 1) {
-      destroy_effect(
-        /** @type {Effect} */
-        effects[i]
-      );
-    }
-  }
-}
-function get_derived_parent_effect(derived) {
-  var parent = derived.parent;
-  while (parent !== null) {
-    if ((parent.f & DERIVED) === 0) {
-      return (
-        /** @type {Effect} */
-        parent
-      );
-    }
-    parent = parent.parent;
-  }
-  return null;
-}
-function execute_derived(derived) {
-  var value;
-  var prev_active_effect = active_effect;
-  set_active_effect(get_derived_parent_effect(derived));
-  {
-    try {
-      destroy_derived_effects(derived);
-      value = update_reaction(derived);
-    } finally {
-      set_active_effect(prev_active_effect);
-    }
-  }
-  return value;
-}
-function update_derived(derived) {
-  var value = execute_derived(derived);
-  if (!derived.equals(value)) {
-    derived.v = value;
-    derived.wv = increment_write_version();
-  }
-  if (is_destroying_effect) return;
-  var status = (skip_reaction || (derived.f & UNOWNED) !== 0) && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
-  set_signal_status(derived, status);
-}
-const old_values = /* @__PURE__ */ new Map();
-function source(v, stack) {
-  var signal = {
-    f: 0,
-    // TODO ideally we could skip this altogether, but it causes type errors
-    v,
-    reactions: null,
-    equals,
-    rv: 0,
-    wv: 0
-  };
-  return signal;
-}
-// @__NO_SIDE_EFFECTS__
-function state(v, stack) {
-  const s = source(v);
-  push_reaction_value(s);
-  return s;
-}
-// @__NO_SIDE_EFFECTS__
-function mutable_source(initial_value, immutable = false, trackable = true) {
-  const s = source(initial_value);
-  if (!immutable) {
-    s.equals = safe_equals;
-  }
-  return s;
-}
-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 | INSPECT_EFFECT)) !== 0 && !(source_ownership?.reaction === active_reaction && source_ownership.sources.includes(source2))) {
-    state_unsafe_mutation();
-  }
-  let new_value = should_proxy ? proxy(value) : value;
-  return internal_set(source2, new_value);
-}
-function internal_set(source2, value) {
-  if (!source2.equals(value)) {
-    var old_value = source2.v;
-    if (is_destroying_effect) {
-      old_values.set(source2, value);
-    } else {
-      old_values.set(source2, old_value);
-    }
-    source2.v = value;
-    if ((source2.f & DERIVED) !== 0) {
-      if ((source2.f & DIRTY) !== 0) {
-        execute_derived(
-          /** @type {Derived} */
-          source2
-        );
-      }
-      set_signal_status(source2, (source2.f & UNOWNED) === 0 ? CLEAN : MAYBE_DIRTY);
-    }
-    source2.wv = increment_write_version();
-    mark_reactions(source2, DIRTY);
-    if (active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
-      if (untracked_writes === null) {
-        set_untracked_writes([source2]);
-      } else {
-        untracked_writes.push(source2);
-      }
-    }
-  }
-  return value;
-}
-function mark_reactions(signal, status) {
-  var reactions = signal.reactions;
-  if (reactions === null) return;
-  var length = reactions.length;
-  for (var i = 0; i < length; i++) {
-    var reaction = reactions[i];
-    var flags = reaction.f;
-    if ((flags & DIRTY) !== 0) continue;
-    set_signal_status(reaction, status);
-    if ((flags & (CLEAN | UNOWNED)) !== 0) {
-      if ((flags & DERIVED) !== 0) {
-        mark_reactions(
-          /** @type {Derived} */
-          reaction,
-          MAYBE_DIRTY
-        );
-      } else {
-        schedule_effect(
-          /** @type {Effect} */
-          reaction
-        );
-      }
-    }
-  }
-}
-function hydration_mismatch(location) {
-  {
-    console.warn(`https://svelte.dev/e/hydration_mismatch`);
-  }
-}
-let hydrating = false;
-function set_hydrating(value) {
-  hydrating = value;
-}
-let hydrate_node;
-function set_hydrate_node(node) {
-  if (node === null) {
-    hydration_mismatch();
-    throw HYDRATION_ERROR;
-  }
-  return hydrate_node = node;
-}
-function hydrate_next() {
-  return set_hydrate_node(
-    /** @type {TemplateNode} */
-    /* @__PURE__ */ get_next_sibling(hydrate_node)
+        get(version);
+        var own_keys = Reflect.ownKeys(target).filter((key2) => {
+          var source3 = sources.get(key2);
+          return source3 === void 0 || source3.v !== UNINITIALIZED;
+        });
+        for (var [key, source2] of sources) {
+          if (source2.v !== UNINITIALIZED && !(key in target)) {
+            own_keys.push(key);
+          }
+        }
+        return own_keys;
+      },
+      setPrototypeOf() {
+        state_prototype_fixed();
+      }
+    }
   );
 }
 var $window;
@@ -507,6 +947,9 @@ function push_effect(effect, parent_effect) {
 }
 function create_effect(type, fn, sync, push2 = true) {
   var parent = active_effect;
+  if (parent !== null && (parent.f & INERT) !== 0) {
+    type |= INERT;
+  }
   var effect = {
     ctx: component_context,
     deps: null,
@@ -536,7 +979,7 @@ function create_effect(type, fn, sync, push2 = true) {
   } else if (fn !== null) {
     schedule_effect(effect);
   }
-  var inert = sync && effect.deps === null && effect.first === null && effect.nodes_start === null && effect.teardown === null && (effect.f & (EFFECT_PRESERVED | BOUNDARY_EFFECT)) === 0;
+  var inert = sync && effect.deps === null && effect.first === null && effect.nodes_start === null && effect.teardown === null && (effect.f & EFFECT_PRESERVED) === 0;
   if (!inert && push2) {
     if (parent !== null) {
       push_effect(effect, parent);
@@ -551,16 +994,11 @@ function create_effect(type, fn, sync, push2 = true) {
   }
   return effect;
 }
-function teardown(fn) {
-  const effect = create_effect(RENDER_EFFECT, null, false);
-  set_signal_status(effect, CLEAN);
-  effect.teardown = fn;
-  return effect;
-}
 function create_user_effect(fn) {
   return create_effect(EFFECT | USER_EFFECT, fn, false);
 }
 function component_root(fn) {
+  Batch.ensure();
   const effect = create_effect(ROOT_EFFECT, fn, true);
   return (options2 = {}) => {
     return new Promise((fulfil) => {
@@ -577,17 +1015,17 @@ function component_root(fn) {
   };
 }
 function branch(fn, push2 = true) {
-  return create_effect(RENDER_EFFECT | BRANCH_EFFECT, fn, true, push2);
+  return create_effect(BRANCH_EFFECT, fn, true, push2);
 }
 function execute_effect_teardown(effect) {
-  var teardown2 = effect.teardown;
-  if (teardown2 !== null) {
+  var teardown = effect.teardown;
+  if (teardown !== null) {
     const previously_destroying_effect = is_destroying_effect;
     const previous_reaction = active_reaction;
     set_is_destroying_effect(true);
     set_active_reaction(null);
     try {
-      teardown2.call(null);
+      teardown.call(null);
     } finally {
       set_is_destroying_effect(previously_destroying_effect);
       set_active_reaction(previous_reaction);
@@ -702,61 +1140,14 @@ function pause_children(effect, transitions, local) {
     child = sibling;
   }
 }
-let micro_tasks = [];
-let idle_tasks = [];
-function run_micro_tasks() {
-  var tasks = micro_tasks;
-  micro_tasks = [];
-  run_all(tasks);
-}
-function run_idle_tasks() {
-  var tasks = idle_tasks;
-  idle_tasks = [];
-  run_all(tasks);
-}
-function flush_tasks() {
-  if (micro_tasks.length > 0) {
-    run_micro_tasks();
-  }
-  if (idle_tasks.length > 0) {
-    run_idle_tasks();
-  }
-}
-function handle_error(error) {
-  var effect = (
-    /** @type {Effect} */
-    active_effect
-  );
-  if ((effect.f & EFFECT_RAN) === 0) {
-    if ((effect.f & BOUNDARY_EFFECT) === 0) {
-      throw error;
-    }
-    effect.fn(error);
-  } else {
-    invoke_error_boundary(error, effect);
-  }
-}
-function invoke_error_boundary(error, effect) {
-  while (effect !== null) {
-    if ((effect.f & BOUNDARY_EFFECT) !== 0) {
-      try {
-        effect.b.error(error);
-        return;
-      } catch {
-      }
-    }
-    effect = effect.parent;
-  }
-  throw error;
-}
-let is_flushing = false;
-let last_scheduled_effect = null;
 let is_updating_effect = false;
+function set_is_updating_effect(value) {
+  is_updating_effect = value;
+}
 let is_destroying_effect = false;
 function set_is_destroying_effect(value) {
   is_destroying_effect = value;
 }
-let queued_root_effects = [];
 let active_reaction = null;
 let untracking = false;
 function set_active_reaction(reaction) {
@@ -766,13 +1157,13 @@ let active_effect = null;
 function set_active_effect(effect) {
   active_effect = effect;
 }
-let source_ownership = null;
+let current_sources = null;
 function push_reaction_value(value) {
-  if (active_reaction !== null && active_reaction.f & EFFECT_IS_UPDATING) {
-    if (source_ownership === null) {
-      source_ownership = { reaction: active_reaction, sources: [value] };
+  if (active_reaction !== null && true) {
+    if (current_sources === null) {
+      current_sources = [value];
     } else {
-      source_ownership.sources.push(value);
+      current_sources.push(value);
     }
   }
 }
@@ -784,11 +1175,15 @@ function set_untracked_writes(value) {
 }
 let write_version = 1;
 let read_version = 0;
+let update_version = read_version;
+function set_update_version(value) {
+  update_version = value;
+}
 let skip_reaction = false;
 function increment_write_version() {
   return ++write_version;
 }
-function check_dirtiness(reaction) {
+function is_dirty(reaction) {
   var flags = reaction.f;
   if ((flags & DIRTY) !== 0) {
     return true;
@@ -802,7 +1197,7 @@ function check_dirtiness(reaction) {
       var is_disconnected = (flags & DISCONNECTED) !== 0;
       var is_unowned_connected = is_unowned && active_effect !== null && !skip_reaction;
       var length = dependencies.length;
-      if (is_disconnected || is_unowned_connected) {
+      if ((is_disconnected || is_unowned_connected) && (active_effect === null || (active_effect.f & DESTROYED) === 0)) {
         var derived = (
           /** @type {Derived} */
           reaction
@@ -823,7 +1218,7 @@ function check_dirtiness(reaction) {
       }
       for (i = 0; i < length; i++) {
         dependency = dependencies[i];
-        if (check_dirtiness(
+        if (is_dirty(
           /** @type {Derived} */
           dependency
         )) {
@@ -846,11 +1241,11 @@ function check_dirtiness(reaction) {
 function schedule_possible_effect_self_invalidation(signal, effect, root2 = true) {
   var reactions = signal.reactions;
   if (reactions === null) return;
+  if (current_sources?.includes(signal)) {
+    return;
+  }
   for (var i = 0; i < reactions.length; i++) {
     var reaction = reactions[i];
-    if (source_ownership?.reaction === active_reaction && source_ownership.sources.includes(signal)) {
-      continue;
-    }
     if ((reaction.f & DERIVED) !== 0) {
       schedule_possible_effect_self_invalidation(
         /** @type {Derived} */
@@ -877,9 +1272,10 @@ function update_reaction(reaction) {
   var previous_untracked_writes = untracked_writes;
   var previous_reaction = active_reaction;
   var previous_skip_reaction = skip_reaction;
-  var previous_reaction_sources = source_ownership;
+  var previous_sources = current_sources;
   var previous_component_context = component_context;
   var previous_untracking = untracking;
+  var previous_update_version = update_version;
   var flags = reaction.f;
   new_deps = /** @type {null | Value[]} */
   null;
@@ -887,16 +1283,16 @@ function update_reaction(reaction) {
   untracked_writes = null;
   skip_reaction = (flags & UNOWNED) !== 0 && (untracking || !is_updating_effect || active_reaction === null);
   active_reaction = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
-  source_ownership = null;
+  current_sources = null;
   set_component_context(reaction.ctx);
   untracking = false;
-  read_version++;
-  reaction.f |= EFFECT_IS_UPDATING;
+  update_version = ++read_version;
   if (reaction.ac !== null) {
     reaction.ac.abort(STALE_REACTION);
     reaction.ac = null;
   }
   try {
+    reaction.f |= REACTION_IS_UPDATING;
     var result = (
       /** @type {Function} */
       (0, reaction.fn)()
@@ -945,19 +1341,23 @@ function update_reaction(reaction) {
         }
       }
     }
+    if ((reaction.f & ERROR_VALUE) !== 0) {
+      reaction.f ^= ERROR_VALUE;
+    }
     return result;
   } catch (error) {
-    handle_error(error);
+    return handle_error(error);
   } finally {
+    reaction.f ^= REACTION_IS_UPDATING;
     new_deps = previous_deps;
     skipped_deps = previous_skipped_deps;
     untracked_writes = previous_untracked_writes;
     active_reaction = previous_reaction;
     skip_reaction = previous_skip_reaction;
-    source_ownership = previous_reaction_sources;
+    current_sources = previous_sources;
     set_component_context(previous_component_context);
     untracking = previous_untracking;
-    reaction.f ^= EFFECT_IS_UPDATING;
+    update_version = previous_update_version;
   }
 }
 function remove_reaction(signal, dependency) {
@@ -1017,158 +1417,41 @@ function update_effect(effect) {
       destroy_effect_children(effect);
     }
     execute_effect_teardown(effect);
-    var teardown2 = update_reaction(effect);
-    effect.teardown = typeof teardown2 === "function" ? teardown2 : null;
+    var teardown = update_reaction(effect);
+    effect.teardown = typeof teardown === "function" ? teardown : null;
     effect.wv = write_version;
     var dep;
     if (DEV && tracing_mode_flag && (effect.f & DIRTY) !== 0 && effect.deps !== null) ;
-    if (DEV) ;
   } finally {
     is_updating_effect = was_updating_effect;
     active_effect = previous_effect;
   }
 }
-function infinite_loop_guard() {
-  try {
-    effect_update_depth_exceeded();
-  } catch (error) {
-    if (last_scheduled_effect !== null) {
-      {
-        invoke_error_boundary(error, last_scheduled_effect);
-      }
-    } else {
-      throw error;
-    }
-  }
-}
-function flush_queued_root_effects() {
-  var was_updating_effect = is_updating_effect;
-  try {
-    var flush_count = 0;
-    is_updating_effect = true;
-    while (queued_root_effects.length > 0) {
-      if (flush_count++ > 1e3) {
-        infinite_loop_guard();
-      }
-      var root_effects = queued_root_effects;
-      var length = root_effects.length;
-      queued_root_effects = [];
-      for (var i = 0; i < length; i++) {
-        var collected_effects = process_effects(root_effects[i]);
-        flush_queued_effects(collected_effects);
-      }
-      old_values.clear();
-    }
-  } finally {
-    is_flushing = false;
-    is_updating_effect = was_updating_effect;
-    last_scheduled_effect = 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 (check_dirtiness(effect)) {
-        var wv = write_version;
-        update_effect(effect);
-        if (effect.deps === null && effect.first === null && effect.nodes_start === null) {
-          if (effect.teardown === null) {
-            unlink_effect(effect);
-          } else {
-            effect.fn = null;
-          }
-        }
-        if (write_version > wv && (effect.f & USER_EFFECT) !== 0) {
-          break;
-        }
-      }
-    }
-  }
-  for (; i < length; i += 1) {
-    schedule_effect(effects[i]);
-  }
-}
-function schedule_effect(signal) {
-  if (!is_flushing) {
-    is_flushing = true;
-    queueMicrotask(flush_queued_root_effects);
-  }
-  var effect = last_scheduled_effect = signal;
-  while (effect.parent !== null) {
-    effect = effect.parent;
-    var flags = effect.f;
-    if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
-      if ((flags & CLEAN) === 0) return;
-      effect.f ^= CLEAN;
-    }
-  }
-  queued_root_effects.push(effect);
-}
-function process_effects(root2) {
-  var effects = [];
-  var effect = root2;
-  while (effect !== null) {
-    var flags = effect.f;
-    var is_branch = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
-    var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
-    if (!is_skippable_branch && (flags & INERT) === 0) {
-      if ((flags & EFFECT) !== 0) {
-        effects.push(effect);
-      } else if (is_branch) {
-        effect.f ^= CLEAN;
-      } else {
-        if (check_dirtiness(effect)) {
-          update_effect(effect);
-        }
-      }
-      var child = effect.first;
-      if (child !== null) {
-        effect = child;
-        continue;
-      }
-    }
-    var parent = effect.parent;
-    effect = effect.next;
-    while (effect === null && parent !== null) {
-      effect = parent.next;
-      parent = parent.parent;
-    }
-  }
-  return effects;
-}
-function flushSync(fn) {
-  var result;
-  while (true) {
-    flush_tasks();
-    if (queued_root_effects.length === 0) {
-      is_flushing = false;
-      last_scheduled_effect = null;
-      return (
-        /** @type {T} */
-        result
-      );
-    }
-    is_flushing = true;
-    flush_queued_root_effects();
-  }
-}
 function get(signal) {
   var flags = signal.f;
   var is_derived = (flags & DERIVED) !== 0;
   if (active_reaction !== null && !untracking) {
-    if (source_ownership?.reaction !== active_reaction || !source_ownership?.sources.includes(signal)) {
+    var destroyed = active_effect !== null && (active_effect.f & DESTROYED) !== 0;
+    if (!destroyed && !current_sources?.includes(signal)) {
       var deps = active_reaction.deps;
-      if (signal.rv < read_version) {
-        signal.rv = read_version;
-        if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
-          skipped_deps++;
-        } else if (new_deps === null) {
-          new_deps = [signal];
-        } else if (!skip_reaction || !new_deps.includes(signal)) {
-          new_deps.push(signal);
+      if ((active_reaction.f & REACTION_IS_UPDATING) !== 0) {
+        if (signal.rv < read_version) {
+          signal.rv = read_version;
+          if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
+            skipped_deps++;
+          } else if (new_deps === null) {
+            new_deps = [signal];
+          } else if (!skip_reaction || !new_deps.includes(signal)) {
+            new_deps.push(signal);
+          }
+        }
+      } else {
+        (active_reaction.deps ??= []).push(signal);
+        var reactions = signal.reactions;
+        if (reactions === null) {
+          signal.reactions = [active_reaction];
+        } else if (!reactions.includes(active_reaction)) {
+          reactions.push(active_reaction);
         }
       }
     }
@@ -1184,18 +1467,51 @@ function get(signal) {
       derived.f ^= UNOWNED;
     }
   }
-  if (is_derived) {
+  if (is_destroying_effect) {
+    if (old_values.has(signal)) {
+      return old_values.get(signal);
+    }
+    if (is_derived) {
+      derived = /** @type {Derived} */
+      signal;
+      var value = derived.v;
+      if ((derived.f & CLEAN) === 0 && derived.reactions !== null || depends_on_old_values(derived)) {
+        value = execute_derived(derived);
+      }
+      old_values.set(derived, value);
+      return value;
+    }
+  } else if (is_derived) {
     derived = /** @type {Derived} */
     signal;
-    if (check_dirtiness(derived)) {
+    if (batch_deriveds?.has(derived)) {
+      return batch_deriveds.get(derived);
+    }
+    if (is_dirty(derived)) {
       update_derived(derived);
     }
   }
-  if (is_destroying_effect && old_values.has(signal)) {
-    return old_values.get(signal);
+  if ((signal.f & ERROR_VALUE) !== 0) {
+    throw signal.v;
   }
   return signal.v;
 }
+function depends_on_old_values(derived) {
+  if (derived.v === UNINITIALIZED) return true;
+  if (derived.deps === null) return false;
+  for (const dep of derived.deps) {
+    if (old_values.has(dep)) {
+      return true;
+    }
+    if ((dep.f & DERIVED) !== 0 && depends_on_old_values(
+      /** @type {Derived} */
+      dep
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
 const STATUS_MASK = -7169;
 function set_signal_status(signal, status) {
   signal.f = signal.f & STATUS_MASK | status;
@@ -1577,32 +1893,33 @@ function Root($$payload, $$props) {
   }
   const Pyramid_1 = constructors[1];
   if (constructors[1]) {
-    $$payload.out += "<!--[-->";
+    $$payload.out.push("<!--[-->");
     const Pyramid_0 = constructors[0];
-    $$payload.out += `<!---->`;
+    $$payload.out.push(`<!---->`);
     Pyramid_0($$payload, {
       data: data_0,
       form,
+      params: page.params,
       children: ($$payload2) => {
-        $$payload2.out += `<!---->`;
-        Pyramid_1($$payload2, { data: data_1, form });
-        $$payload2.out += `<!---->`;
+        $$payload2.out.push(`<!---->`);
+        Pyramid_1($$payload2, { data: data_1, form, params: page.params });
+        $$payload2.out.push(`<!---->`);
       },
       $$slots: { default: true }
     });
-    $$payload.out += `<!---->`;
+    $$payload.out.push(`<!---->`);
   } else {
-    $$payload.out += "<!--[!-->";
+    $$payload.out.push("<!--[!-->");
     const Pyramid_0 = constructors[0];
-    $$payload.out += `<!---->`;
-    Pyramid_0($$payload, { data: data_0, form });
-    $$payload.out += `<!---->`;
+    $$payload.out.push(`<!---->`);
+    Pyramid_0($$payload, { data: data_0, form, params: page.params });
+    $$payload.out.push(`<!---->`);
   }
-  $$payload.out += `<!--]--> `;
+  $$payload.out.push(`<!--]--> `);
   {
-    $$payload.out += "<!--[!-->";
+    $$payload.out.push("<!--[!-->");
   }
-  $$payload.out += `<!--]-->`;
+  $$payload.out.push(`<!--]-->`);
   pop$1();
 }
 const root = asClassComponent(Root);
@@ -1692,7 +2009,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: "1p7g1km"
+  version_hash: "vcxt80"
 };
 async function get_hooks() {
   let handle;
@@ -2739,112 +3056,6 @@ function with_event(event, fn) {
     request_event = null;
   }
 }
-class HttpError {
-  /**
-   * @param {number} status
-   * @param {{message: string} extends App.Error ? (App.Error | string | undefined) : App.Error} body
-   */
-  constructor(status, body2) {
-    this.status = status;
-    if (typeof body2 === "string") {
-      this.body = { message: body2 };
-    } else if (body2) {
-      this.body = body2;
-    } else {
-      this.body = { message: `Error: ${status}` };
-    }
-  }
-  toString() {
-    return JSON.stringify(this.body);
-  }
-}
-class Redirect {
-  /**
-   * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status
-   * @param {string} location
-   */
-  constructor(status, location) {
-    this.status = status;
-    this.location = location;
-  }
-}
-class SvelteKitError extends Error {
-  /**
-   * @param {number} status
-   * @param {string} text
-   * @param {string} message
-   */
-  constructor(status, text2, message) {
-    super(message);
-    this.status = status;
-    this.text = text2;
-  }
-}
-class ActionFailure {
-  /**
-   * @param {number} status
-   * @param {T} data
-   */
-  constructor(status, data) {
-    this.status = status;
-    this.data = data;
-  }
-}
-const DATA_SUFFIX = "/__data.json";
-const HTML_DATA_SUFFIX = ".html__data.json";
-function has_data_suffix(pathname) {
-  return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
-}
-function add_data_suffix(pathname) {
-  if (pathname.endsWith(".html")) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
-  return pathname.replace(/\/$/, "") + DATA_SUFFIX;
-}
-function strip_data_suffix(pathname) {
-  if (pathname.endsWith(HTML_DATA_SUFFIX)) {
-    return pathname.slice(0, -HTML_DATA_SUFFIX.length) + ".html";
-  }
-  return pathname.slice(0, -DATA_SUFFIX.length);
-}
-const ROUTE_SUFFIX = "/__route.js";
-function has_resolution_suffix(pathname) {
-  return pathname.endsWith(ROUTE_SUFFIX);
-}
-function add_resolution_suffix(pathname) {
-  return pathname.replace(/\/$/, "") + ROUTE_SUFFIX;
-}
-function strip_resolution_suffix(pathname) {
-  return pathname.slice(0, -ROUTE_SUFFIX.length);
-}
-function json(data, init2) {
-  const body2 = JSON.stringify(data);
-  const headers2 = new Headers(init2?.headers);
-  if (!headers2.has("content-length")) {
-    headers2.set("content-length", encoder$3.encode(body2).byteLength.toString());
-  }
-  if (!headers2.has("content-type")) {
-    headers2.set("content-type", "application/json");
-  }
-  return new Response(body2, {
-    ...init2,
-    headers: headers2
-  });
-}
-const encoder$3 = new TextEncoder();
-function text(body2, init2) {
-  const headers2 = new Headers(init2?.headers);
-  if (!headers2.has("content-length")) {
-    const encoded = encoder$3.encode(body2);
-    headers2.set("content-length", encoded.byteLength.toString());
-    return new Response(encoded, {
-      ...init2,
-      headers: headers2
-    });
-  }
-  return new Response(body2, {
-    ...init2,
-    headers: headers2
-  });
-}
 function coalesce_to_error(err) {
   return err instanceof Error || err && /** @type {any} */
   err.name && /** @type {any} */
@@ -2855,7 +3066,7 @@ function coalesce_to_error(err) {
 }
 function normalize_error(error) {
   return (
-    /** @type {import('../runtime/control.js').Redirect | HttpError | SvelteKitError | Error} */
+    /** @type {import('../exports/internal/index.js').Redirect | HttpError | SvelteKitError | Error} */
     error
   );
 }
@@ -2955,7 +3166,7 @@ function redirect_response(status, location) {
 }
 function clarify_devalue_error(event, error) {
   if (error.path) {
-    return `Data returned from \`load\` while rendering ${event.route.id} is not serializable: ${error.message} (${error.path})`;
+    return `Data returned from \`load\` while rendering ${event.route.id} is not serializable: ${error.message} (${error.path}). If you need to serialize/deserialize custom types, use transport hooks: https://svelte.dev/docs/kit/hooks#Universal-hooks-transport.`;
   }
   if (error.path === "") {
     return `Data returned from \`load\` while rendering ${event.route.id} is not a plain object`;
@@ -3063,6 +3274,31 @@ function compact(arr) {
     (val) => val != null
   );
 }
+const DATA_SUFFIX = "/__data.json";
+const HTML_DATA_SUFFIX = ".html__data.json";
+function has_data_suffix(pathname) {
+  return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
+}
+function add_data_suffix(pathname) {
+  if (pathname.endsWith(".html")) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
+  return pathname.replace(/\/$/, "") + DATA_SUFFIX;
+}
+function strip_data_suffix(pathname) {
+  if (pathname.endsWith(HTML_DATA_SUFFIX)) {
+    return pathname.slice(0, -HTML_DATA_SUFFIX.length) + ".html";
+  }
+  return pathname.slice(0, -DATA_SUFFIX.length);
+}
+const ROUTE_SUFFIX = "/__route.js";
+function has_resolution_suffix(pathname) {
+  return pathname.endsWith(ROUTE_SUFFIX);
+}
+function add_resolution_suffix(pathname) {
+  return pathname.replace(/\/$/, "") + ROUTE_SUFFIX;
+}
+function strip_resolution_suffix(pathname) {
+  return pathname.slice(0, -ROUTE_SUFFIX.length);
+}
 function is_action_json_request(event) {
   const accept = negotiate(event.request.headers.get("accept") ?? "*/*", [
     "application/json",
@@ -5948,10 +6184,7 @@ class Server {
     this.#manifest = manifest;
   }
   /**
-   * @param {{
-   *   env: Record<string, string>;
-   *   read?: (file: string) => ReadableStream;
-   * }} opts
+   * @param {import('@sveltejs/kit').ServerInitOptions} opts
    */
   async init({ env, read }) {
     const prefixes = {
@@ -5965,7 +6198,34 @@ class Server {
     );
     set_safe_public_env(public_env2);
     if (read) {
-      set_read_implementation(read);
+      const wrapped_read = (file) => {
+        const result = read(file);
+        if (result instanceof ReadableStream) {
+          return result;
+        } else {
+          return new ReadableStream({
+            async start(controller) {
+              try {
+                const stream = await Promise.resolve(result);
+                if (!stream) {
+                  controller.close();
+                  return;
+                }
+                const reader = stream.getReader();
+                while (true) {
+                  const { done, value } = await reader.read();
+                  if (done) break;
+                  controller.enqueue(value);
+                }
+                controller.close();
+              } catch (error) {
+                controller.error(error);
+              }
+            }
+          });
+        }
+      };
+      set_read_implementation(wrapped_read);
     }
     await (init_promise ??= (async () => {
       try {